AnmeldungClient hinzugefügt

KSGNetwork/AnmeldungClient.cpp

@@ -0,0 +1,759 @@
+#include "AnmeldungClient.h"
+#include <Klient.h>
+#include "Keys.h"
+#include <Globals.h>
+
+using namespace KSGClient;
+
+// Inhalt der Anmeldung Klasse
+
+// Konstruktor
+AnmeldungClient::AnmeldungClient( 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
+AnmeldungClient::~AnmeldungClient()
+{
+    trenne( 1 );
+    delete[] key;
+}
+
+// verbindet sich mit dem zugewiesenen Anmeldung Server
+//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
+bool AnmeldungClient::verbinde()
+{
+    cs.lock();
+    if( k )
+    {
+        cs.unlock();
+        return 1;
+    }
+    k = new Network::Klient();
+    int l = 0;
+    char *key;
+    Keys::getServerKey( &key, l, Keys::ANMELDUNG, Keys::SENDEN );
+    k->setSendeKey( key, l );
+    delete[] key;
+    Keys::getServerKey( &key, l, Keys::ANMELDUNG, 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 Anmeldung Server returned: ";
+                err += f;
+                delete[]f;
+                trenne( 0 );
+                cs.unlock();
+                return 0;
+            }
+            k->setSendeKey( this->key, this->keyLen );
+            k->setEmpfangKey( this->key, this->keyLen );
+        }
+        else
+        {
+            err = "network error while sending to Anmeldung Server";
+            k = k->release();
+            cs.unlock();
+            return 0;
+        }
+    }
+    else
+    {
+        err = "network error while connecting to Anmeldung Server";
+        k = k->release();
+        cs.unlock();
+        return 0;
+    }
+    cs.unlock();
+    return 1;
+}
+
+// erstellt eine gruppe
+//  karteId: Die Id der Karte für die die Gruppe erstellt werden soll
+//  Gibt bei Erfolg die Id der Gruppe zurück. Bei misserfolg wird 0 zurückgegeben
+int AnmeldungClient::gruppeErstellen( int karteId )
+{
+    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 )
+    {
+        k->sendeEncrypted( (char*)&karteId, 4 );
+        k->getNachrichtEncrypted( &serverReturn, 1 );
+        if( serverReturn == 1 )
+        {
+            int gruppeId = 0;
+            k->getNachrichtEncrypted( (char*)&gruppeId, 4 );
+            cs.unlock();
+            return gruppeId;
+        }
+    }
+    if( serverReturn == 3 )
+    {
+        char län = 0;
+        k->getNachrichtEncrypted( &län, 1 );
+        char *message = new char[ län + 1 ];
+        message[ län ] = 0;
+        k->getNachrichtEncrypted( message, län );
+        err = message;
+        delete[] message;
+        cs.unlock();
+        return 0;
+    }
+    err = "Unbekannter Fehler";
+    cs.unlock();
+    return 0;
+}
+
+// Betritt eine Gruppe
+//  gruppeId: Die Id der Gruppe
+//  mitglieder: Nach erfolgreichem Aufruf enthält diese Liste die Lister der Account Ids der Gruppenmitglieder
+//  anzahl: Nach erfolgreichem Aufruf wird hier die Anzahl der Gruppenmitglieder gespeichert
+//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
+bool AnmeldungClient::gruppeBetreten( int gruppeId, Framework::Array< int > *mitglieder, int *anzahl )
+{
+    cs.lock();
+    if( !k )
+    {
+        err = "Der Client ist nicht verbunden.";
+        cs.unlock();
+        return 0;
+    }
+    k->sendeEncrypted( "\x6", 1 );
+    char serverReturn = 0;
+    k->getNachrichtEncrypted( &serverReturn, 1 );
+    if( serverReturn == 1 )
+    {
+        k->sendeEncrypted( (char*)&gruppeId, 4 );
+        k->getNachrichtEncrypted( &serverReturn, 1 );
+        if( serverReturn == 1 )
+        {
+            k->getNachrichtEncrypted( (char*)anzahl, 4 );
+            for( int i = 0; i < *anzahl; i++ )
+            {
+                int id = 0;
+                k->getNachrichtEncrypted( (char*)&id, 4 );
+                mitglieder->add( id, i );
+            }
+            cs.unlock();
+            return 1;
+        }
+    }
+    if( serverReturn == 3 )
+    {
+        char län = 0;
+        k->getNachrichtEncrypted( &län, 1 );
+        char *message = new char[ län + 1 ];
+        message[ län ] = 0;
+        k->getNachrichtEncrypted( message, län );
+        err = message;
+        delete[] message;
+        cs.unlock();
+        return 0;
+    }
+    err = "Unbekannter Fehler";
+    cs.unlock();
+    return 0;
+}
+
+// Verlässt eine Gruppe
+//  gruppeId: Die Id der Gruppe
+//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
+bool AnmeldungClient::gruppeVerlassen( int gruppeId )
+{
+    cs.lock();
+    if( !k )
+    {
+        err = "Der Client ist nicht verbunden.";
+        cs.unlock();
+        return 0;
+    }
+    k->sendeEncrypted( "\x7", 1 );
+    char serverReturn = 0;
+    k->getNachrichtEncrypted( &serverReturn, 1 );
+    if( serverReturn == 1 )
+    {
+        k->sendeEncrypted( (char*)&gruppeId, 4 );
+        k->getNachrichtEncrypted( &serverReturn, 1 );
+        if( serverReturn == 1 )
+        {
+            cs.unlock();
+            return 1;
+        }
+    }
+    if( serverReturn == 3 )
+    {
+        char län = 0;
+        k->getNachrichtEncrypted( &län, 1 );
+        char *message = new char[ län + 1 ];
+        message[ län ] = 0;
+        k->getNachrichtEncrypted( message, län );
+        err = message;
+        delete[] message;
+        cs.unlock();
+        return 0;
+    }
+    err = "Unbekannter Fehler";
+    cs.unlock();
+    return 0;
+}
+
+// Trägt die Gruppe in die Warteschlange für die Karte ein (nur für den Gruppen Administrator)
+//  gruppeId: Die Id der Gruppe
+//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
+bool AnmeldungClient::gruppeAnmelden( int gruppeId )
+{
+    cs.lock();
+    if( !k )
+    {
+        err = "Der Client ist nicht verbunden.";
+        cs.unlock();
+        return 0;
+    }
+    k->sendeEncrypted( "\x9", 1 );
+    char serverReturn = 0;
+    k->getNachrichtEncrypted( &serverReturn, 1 );
+    if( serverReturn == 1 )
+    {
+        k->sendeEncrypted( (char*)&gruppeId, 4 );
+        k->getNachrichtEncrypted( &serverReturn, 1 );
+        if( serverReturn == 1 )
+        {
+            cs.unlock();
+            return 1;
+        }
+    }
+    if( serverReturn == 3 )
+    {
+        char län = 0;
+        k->getNachrichtEncrypted( &län, 1 );
+        char *message = new char[ län + 1 ];
+        message[ län ] = 0;
+        k->getNachrichtEncrypted( message, län );
+        err = message;
+        delete[] message;
+        cs.unlock();
+        return 0;
+    }
+    err = "Unbekannter Fehler";
+    cs.unlock();
+    return 0;
+}
+
+// Trägt die Gruppe aus der Warteschlange für die Karte aus (nur für den Gruppen Administrator)
+//  gruppeId: Die Id der Gruppe
+//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
+bool AnmeldungClient::gruppeAbmelden( int gruppeId )
+{
+    cs.lock();
+    if( !k )
+    {
+        err = "Der Client ist nicht verbunden.";
+        cs.unlock();
+        return 0;
+    }
+    k->sendeEncrypted( "\xA", 1 );
+    char serverReturn = 0;
+    k->getNachrichtEncrypted( &serverReturn, 1 );
+    if( serverReturn == 1 )
+    {
+        k->sendeEncrypted( (char*)&gruppeId, 4 );
+        k->getNachrichtEncrypted( &serverReturn, 1 );
+        if( serverReturn == 1 )
+        {
+            cs.unlock();
+            return 1;
+        }
+    }
+    if( serverReturn == 3 )
+    {
+        char län = 0;
+        k->getNachrichtEncrypted( &län, 1 );
+        char *message = new char[ län + 1 ];
+        message[ län ] = 0;
+        k->getNachrichtEncrypted( message, län );
+        err = message;
+        delete[] message;
+        cs.unlock();
+        return 0;
+    }
+    err = "Unbekannter Fehler";
+    cs.unlock();
+    return 0;
+}
+
+// läht Spieler ein die Gruppe zu betreten (nur für den Gruppen Administrator)
+//  accountId: Die Id des Accounts
+//  gruppeId: Die Id der Gruppe
+//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
+bool AnmeldungClient::gruppeSpielerEinladen( int accountId, int gruppeId )
+{
+    cs.lock();
+    if( !k )
+    {
+        err = "Der Client ist nicht verbunden.";
+        cs.unlock();
+        return 0;
+    }
+    k->sendeEncrypted( "\xB", 1 );
+    char serverReturn = 0;
+    k->getNachrichtEncrypted( &serverReturn, 1 );
+    if( serverReturn == 1 )
+    {
+        k->sendeEncrypted( (char*)&accountId, 4 );
+        k->sendeEncrypted( (char*)&gruppeId, 4 );
+        k->getNachrichtEncrypted( &serverReturn, 1 );
+        if( serverReturn == 1 )
+        {
+            cs.unlock();
+            return 1;
+        }
+    }
+    if( serverReturn == 3 )
+    {
+        char län = 0;
+        k->getNachrichtEncrypted( &län, 1 );
+        char *message = new char[ län + 1 ];
+        message[ län ] = 0;
+        k->getNachrichtEncrypted( message, län );
+        err = message;
+        delete[] message;
+        cs.unlock();
+        return 0;
+    }
+    err = "Unbekannter Fehler";
+    cs.unlock();
+    return 0;
+}
+
+// Zieht die Einladung eine Gruppe zu betreten zurück (nur für den Gruppen Administrator)
+//  accountId: Die Id des Accounts
+//  gruppeId: Die Id der Gruppe
+//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
+bool AnmeldungClient::gruppeEinladungAbbrechen( int accountId, int gruppeId )
+{
+    cs.lock();
+    if( !k )
+    {
+        err = "Der Client ist nicht verbunden.";
+        cs.unlock();
+        return 0;
+    }
+    k->sendeEncrypted( "\x11", 1 );
+    char serverReturn = 0;
+    k->getNachrichtEncrypted( &serverReturn, 1 );
+    if( serverReturn == 1 )
+    {
+        k->sendeEncrypted( (char*)&gruppeId, 4 );
+        k->sendeEncrypted( (char*)&accountId, 4 );
+        k->getNachrichtEncrypted( &serverReturn, 1 );
+        if( serverReturn == 1 )
+        {
+            cs.unlock();
+            return 1;
+        }
+    }
+    if( serverReturn == 3 )
+    {
+        char län = 0;
+        k->getNachrichtEncrypted( &län, 1 );
+        char *message = new char[ län + 1 ];
+        message[ län ] = 0;
+        k->getNachrichtEncrypted( message, län );
+        err = message;
+        delete[] message;
+        cs.unlock();
+        return 0;
+    }
+    err = "Unbekannter Fehler";
+    cs.unlock();
+    return 0;
+}
+
+// Einladung zur Gruppe ablehnen
+//  gruppeId: Die Id der Gruppe
+//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
+bool AnmeldungClient::gruppeEinladungAblehnen( int gruppeId )
+{
+    cs.lock();
+    if( !k )
+    {
+        err = "Der Client ist nicht verbunden.";
+        cs.unlock();
+        return 0;
+    }
+    k->sendeEncrypted( "\x12", 1 );
+    char serverReturn = 0;
+    k->getNachrichtEncrypted( &serverReturn, 1 );
+    if( serverReturn == 1 )
+    {
+        k->sendeEncrypted( (char*)&gruppeId, 4 );
+        k->getNachrichtEncrypted( &serverReturn, 1 );
+        if( serverReturn == 1 )
+        {
+            cs.unlock();
+            return 1;
+        }
+    }
+    if( serverReturn == 3 )
+    {
+        char län = 0;
+        k->getNachrichtEncrypted( &län, 1 );
+        char *message = new char[ län + 1 ];
+        message[ län ] = 0;
+        k->getNachrichtEncrypted( message, län );
+        err = message;
+        delete[] message;
+        cs.unlock();
+        return 0;
+    }
+    err = "Unbekannter Fehler";
+    cs.unlock();
+    return 0;
+}
+
+// wirft Spieler aus Gruppe (nur für den Gruppen Administrator)
+//  accountId: Die Id des Accounts
+//  gruppeId: Die Id der Gruppe
+//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
+bool AnmeldungClient::kickSpielerAusGruppe( int accountId, int gruppeId )
+{
+    cs.lock();
+    if( !k )
+    {
+        err = "Der Client ist nicht verbunden.";
+        cs.unlock();
+        return 0;
+    }
+    k->sendeEncrypted( "\xC", 1 );
+    char serverReturn = 0;
+    k->getNachrichtEncrypted( &serverReturn, 1 );
+    if( serverReturn == 1 )
+    {
+        k->sendeEncrypted( (char*)&accountId, 4 );
+        k->sendeEncrypted( (char*)&gruppeId, 4 );
+        k->getNachrichtEncrypted( &serverReturn, 1 );
+        if( serverReturn == 1 )
+        {
+            cs.unlock();
+            return 1;
+        }
+    }
+    if( serverReturn == 3 )
+    {
+        char län = 0;
+        k->getNachrichtEncrypted( &län, 1 );
+        char *message = new char[ län + 1 ];
+        message[ län ] = 0;
+        k->getNachrichtEncrypted( message, län );
+        err = message;
+        delete[] message;
+        cs.unlock();
+        return 0;
+    }
+    err = "Unbekannter Fehler";
+    cs.unlock();
+    return 0;
+}
+
+// Legt fest, ob die Spieler in der Gruppe alleine spielen wollen, oder ob weitere Spieler aus der Warteschlange hinzugefügt werden sollen bis die Karte voll ist
+//  gruppeId: Die Id der Gruppe
+//  spielStarte: 1:=alleine spielen, 0:=auf volles Spiel warten
+//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
+bool AnmeldungClient::gruppeSpielStarten( int gruppeId, bool spielStarten )
+{
+    cs.lock();
+    if( !k )
+    {
+        err = "Der Client ist nicht verbunden.";
+        cs.unlock();
+        return 0;
+    }
+    k->sendeEncrypted( "\x10", 1 );
+    char serverReturn = 0;
+    k->getNachrichtEncrypted( &serverReturn, 1 );
+    if( serverReturn == 1 )
+    {
+        k->sendeEncrypted( (char*)&gruppeId, 4 );
+        k->sendeEncrypted( (char*)&spielStarten, 1 );
+        k->getNachrichtEncrypted( &serverReturn, 1 );
+        if( serverReturn == 1 )
+        {
+            cs.unlock();
+            return 1;
+        }
+    }
+    if( serverReturn == 3 )
+    {
+        char län = 0;
+        k->getNachrichtEncrypted( &län, 1 );
+        char *message = new char[ län + 1 ];
+        message[ län ] = 0;
+        k->getNachrichtEncrypted( message, län );
+        err = message;
+        delete[] message;
+        cs.unlock();
+        return 0;
+    }
+    err = "Unbekannter Fehler";
+    cs.unlock();
+    return 0;
+}
+
+// Sendet eine Nachricht an den Gruppen Chat
+//  gruppeId: Die Id der Gruppe
+//  nachricht: Die Nachricht, die gesendet werden soll
+//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
+bool AnmeldungClient::gruppeNachricht( int gruppeId, char *nachricht )
+{
+    cs.lock();
+    if( !k )
+    {
+        err = "Der Client ist nicht verbunden.";
+        cs.unlock();
+        return 0;
+    }
+    char län = textLength( nachricht );
+    if( !län )
+        return 1;
+    cs.lock();
+    k->sendeEncrypted( "\xD", 1 );
+    char serverReturn = 0;
+    k->getNachrichtEncrypted( &serverReturn, 1 );
+    if( serverReturn == 1 )
+    {
+        k->sendeEncrypted( (char*)&gruppeId, 4 );
+        k->sendeEncrypted( (char*)&län, 1 );
+        k->sendeEncrypted( nachricht, län );
+        k->getNachrichtEncrypted( &serverReturn, 1 );
+        if( serverReturn == 1 )
+        {
+            cs.unlock();
+            return 1;
+        }
+    }
+    if( serverReturn == 3 )
+    {
+        char län = 0;
+        k->getNachrichtEncrypted( &län, 1 );
+        char *message = new char[ län + 1 ];
+        message[ län ] = 0;
+        k->getNachrichtEncrypted( message, län );
+        err = message;
+        delete[] message;
+        cs.unlock();
+        return 0;
+    }
+    err = "Unbekannter Fehler";
+    cs.unlock();
+    return 0;
+}
+
+// Meldet den eingeloggten Account in der Warteschlange für eine Karte an
+//  karteId: Die Id der Karte
+//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
+bool AnmeldungClient::anmelden( int karteId )
+{
+    cs.lock();
+    if( !k )
+    {
+        err = "Der Client ist nicht verbunden.";
+        cs.unlock();
+        return 0;
+    }
+    k->sendeEncrypted( "\xE", 1 );
+    char serverReturn = 0;
+    k->getNachrichtEncrypted( &serverReturn, 1 );
+    if( serverReturn == 1 )
+    {
+        k->sendeEncrypted( (char*)&karteId, 4 );
+        k->getNachrichtEncrypted( &serverReturn, 1 );
+        if( serverReturn == 1 )
+        {
+            cs.unlock();
+            return 1;
+        }
+    }
+    if( serverReturn == 3 )
+    {
+        char län = 0;
+        k->getNachrichtEncrypted( &län, 1 );
+        char *message = new char[ län + 1 ];
+        message[ län ] = 0;
+        k->getNachrichtEncrypted( message, län );
+        err = message;
+        delete[] message;
+        cs.unlock();
+        return 0;
+    }
+    err = "Unbekannter Fehler";
+    cs.unlock();
+    return 0;
+}
+
+// Meldet den eingeloggten Account aus der Warteschlange ab
+//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
+bool AnmeldungClient::abmelden()
+{
+    cs.lock();
+    if( !k )
+    {
+        err = "Der Client ist nicht verbunden.";
+        cs.unlock();
+        return 0;
+    }
+    k->sendeEncrypted( "\xF", 1 );
+    char serverReturn = 0;
+    k->getNachrichtEncrypted( &serverReturn, 1 );
+    if( serverReturn == 1 )
+    {
+        cs.unlock();
+        return 1;
+    }
+    if( serverReturn == 3 )
+    {
+        char län = 0;
+        k->getNachrichtEncrypted( &län, 1 );
+        char *message = new char[ län + 1 ];
+        message[ län ] = 0;
+        k->getNachrichtEncrypted( message, län );
+        err = message;
+        delete[] message;
+        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 AnmeldungClient::keepAlive()
+{
+    if( !k )
+        return 0;
+    char res = 0;
+    if( !cs.tryLock() )
+        return 1;
+    Framework::logLine( ( char* )"Verbindungstest zum Anmeldung Server..." );
+    bool ok = k->sendeEncrypted( "\x13", 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 AnmeldungClient::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 Anmeldung 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 Anmeldung 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 AnmeldungClient::istVerbunden() const
+{
+    return k != 0;
+}
+
+// gibt den Letzten Fehlertext zuück
+//  sollte erst aufgerufen werden, nachdem eine andere aufgerufene Methode fehlgeschlagen ist
+char *AnmeldungClient::getLetzterFehler() const
+{
+    return err;
+}
+
+// Erhöht den Reference Counter um 1 un gibt this zurück
+AnmeldungServerClient *AnmeldungClient::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 
+AnmeldungServerClient *AnmeldungClient::release()
+{
+    ref--;
+    if( !ref )
+        delete this;
+    return 0;
+}

KSGNetwork/AnmeldungClient.h

@@ -0,0 +1,108 @@
+#pragma once
+
+#include "../Include/KSGNetwork.h"
+#include <Critical.h>
+
+namespace KSGClient
+{
+    // Wird verwendet um sich für Spiele anzumelden
+    //  Kann nur von eingeloggten Clients verwendet werden
+    class AnmeldungClient : public AnmeldungServerClient
+    {
+    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
+        AnmeldungClient( int klientId, unsigned short port, char *ip, char *key, unsigned char keyLen );
+        // Destruktor
+        ~AnmeldungClient();
+        // verbindet sich mit dem zugewiesenen Anmeldung Server
+        //  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
+        bool verbinde() override;
+        // erstellt eine gruppe
+        //  karteId: Die Id der Karte für die die Gruppe erstellt werden soll
+        //  Gibt bei Erfolg die Id der Gruppe zurück. Bei misserfolg wird 0 zurückgegeben
+        int gruppeErstellen( int karteId ) override;
+        // Betritt eine Gruppe
+        //  gruppeId: Die Id der Gruppe
+        //  mitglieder: Nach erfolgreichem Aufruf enthält diese Liste die Lister der Account Ids der Gruppenmitglieder
+        //  anzahl: Nach erfolgreichem Aufruf wird hier die Anzahl der Gruppenmitglieder gespeichert
+        //  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
+        bool gruppeBetreten( int gruppeId, Framework::Array< int > *mitglieder, int *anzahl ) override;
+        // Verlässt eine Gruppe
+        //  gruppeId: Die Id der Gruppe
+        //  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
+        bool gruppeVerlassen( int gruppeId ) override;
+        // Trägt die Gruppe in die Warteschlange für die Karte ein (nur für den Gruppen Administrator)
+        //  gruppeId: Die Id der Gruppe
+        //  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
+        bool gruppeAnmelden( int gruppeId ) override;
+        // Trägt die Gruppe aus der Warteschlange für die Karte aus (nur für den Gruppen Administrator)
+        //  gruppeId: Die Id der Gruppe
+        //  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
+        bool gruppeAbmelden( int gruppeId ) override;
+        // läht Spieler ein die Gruppe zu betreten (nur für den Gruppen Administrator)
+        //  accountId: Die Id des Accounts
+        //  gruppeId: Die Id der Gruppe
+        //  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
+        bool gruppeSpielerEinladen( int accountId, int gruppeId ) override;
+        // Zieht die Einladung eine Gruppe zu betreten zurück (nur für den Gruppen Administrator)
+        //  accountId: Die Id des Accounts
+        //  gruppeId: Die Id der Gruppe
+        //  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
+        bool gruppeEinladungAbbrechen( int accountId, int gruppeId ) override;
+        // Einladung zur Gruppe ablehnen
+        //  gruppeId: Die Id der Gruppe
+        //  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
+        bool gruppeEinladungAblehnen( int gruppeId ) override;
+        // wirft Spieler aus Gruppe (nur für den Gruppen Administrator)
+        //  accountId: Die Id des Accounts
+        //  gruppeId: Die Id der Gruppe
+        //  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
+        bool kickSpielerAusGruppe( int accountId, int gruppeId ) override;
+        // Legt fest, ob die Spieler in der Gruppe alleine spielen wollen, oder ob weitere Spieler aus der Warteschlange hinzugefügt werden sollen bis die Karte voll ist
+        //  gruppeId: Die Id der Gruppe
+        //  spielStarte: 1:=alleine spielen, 0:=auf volles Spiel warten
+        //  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
+        bool gruppeSpielStarten( int gruppeId, bool spielStarten ) override;
+        // Sendet eine Nachricht an den Gruppen Chat
+        //  gruppeId: Die Id der Gruppe
+        //  nachricht: Die Nachricht, die gesendet werden soll
+        //  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
+        bool gruppeNachricht( int gruppeId, char *nachricht ) override;
+        // Meldet den eingeloggten Account in der Warteschlange für eine Karte an
+        //  karteId: Die Id der Karte
+        //  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
+        bool anmelden( int karteId ) override;
+        // Meldet den eingeloggten Account aus der Warteschlange ab
+        //  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
+        bool abmelden() 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
+        AnmeldungServerClient *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 
+        AnmeldungServerClient *release() override;
+    };
+}

KSGNetwork/KSGNetwork.vcxproj

@@ -148,6 +148,7 @@
   </ItemDefinitionGroup>
   <ItemGroup>
     <ClInclude Include="..\Include\KSGNetwork.h" />
+    <ClInclude Include="AnmeldungClient.h" />
     <ClInclude Include="ChatClient.h" />
     <ClInclude Include="ErhaltungClient.h" />
     <ClInclude Include="InformationClient.h" />
@@ -161,6 +162,7 @@
     <ClInclude Include="ShopClient.h" />
   </ItemGroup>
   <ItemGroup>
+    <ClCompile Include="AnmeldungClient.cpp" />
     <ClCompile Include="ChatClient.cpp" />
     <ClCompile Include="ErhaltungClient.cpp" />
     <ClCompile Include="InformationClient.cpp" />

KSGNetwork/KSGNetwork.vcxproj.filters

@@ -51,6 +51,9 @@
     <ClInclude Include="ShopClient.h">
       <Filter>Headerdateien</Filter>
     </ClInclude>
+    <ClInclude Include="AnmeldungClient.h">
+      <Filter>Headerdateien</Filter>
+    </ClInclude>
   </ItemGroup>
   <ItemGroup>
     <ClCompile Include="MainClient.cpp">
@@ -83,5 +86,8 @@
     <ClCompile Include="ShopClient.cpp">
       <Filter>Quelldateien</Filter>
     </ClCompile>
+    <ClCompile Include="AnmeldungClient.cpp">
+      <Filter>Quelldateien</Filter>
+    </ClCompile>
   </ItemGroup>
 </Project>

KSGNetwork/MainClient.cpp

@@ -6,6 +6,9 @@
 #include "NewsClient.h"
 #include "RegisterServer.h"
 #include "LoginClient.h"
+#include "ShopClient.h"
+#include "ChatClient.h"
+#include "AnmeldungClient.h"
 
 using namespace KSGClient;
 
@@ -426,21 +429,156 @@ InformationServerClient *MainClient::createInformationServerClient()
 //  Gibt bei misserfolg 0 zurück
 ChatServerClient *MainClient::createChatServerClient()
 {
-
+    cs.lock();
+    bool connected = k != 0;
+    if( !connected )
+        connect();
+    if( !k )
+    {
+        err = "no connection to Main Server";
+        cs.unlock();
+        return 0;
+    }
+    k->sendeEncrypted( "\6\5", 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 ChatClient( 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 ChatServer server returned: ";
+        err += f;
+        delete[]f;
+    }
+    if( !connected )
+        disconnect();
+    cs.unlock();
+    return 0;
 }
 
 // Erzeugt einen Shop Server Client
 //  Gibt bei misserfolg 0 zurück
 ShopServerClient *MainClient::createShopServerClient()
 {
-
+    cs.lock();
+    bool connected = k != 0;
+    if( !connected )
+        connect();
+    if( !k )
+    {
+        err = "no connection to Main Server";
+        cs.unlock();
+        return 0;
+    }
+    k->sendeEncrypted( "\6\7", 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 ShopClient( 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 ShopServer server returned: ";
+        err += f;
+        delete[]f;
+    }
+    if( !connected )
+        disconnect();
+    cs.unlock();
+    return 0;
 }
 
 // Erzeugt einen Anmeldung Server Client
 //  Gibt bei misserfolg 0 zurück
 AnmeldungServerClient *MainClient::createAnmeldungServerClient()
 {
-
+    cs.lock();
+    bool connected = k != 0;
+    if( !connected )
+        connect();
+    if( !k )
+    {
+        err = "no connection to Main Server";
+        cs.unlock();
+        return 0;
+    }
+    k->sendeEncrypted( "\6\6", 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 AnmeldungClient( 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 ShopServer server returned: ";
+        err += f;
+        delete[]f;
+    }
+    if( !connected )
+        disconnect();
+    cs.unlock();
+    return 0;
 }
 
 // Erzeugt einen Minigame Server Client