KSGNetwork/KSGNetwork/MainClient.cpp

#include "MainClient.h"
#include <Klient.h>
#include "Keys.h"
#include "ErhaltungClient.h"
#include "PatchClient.h"
#include "NewsClient.h"

using namespace KSGClient;

// Inhalt der MainClient Klasse

// Konstruktor
MainClient::MainClient()
{
    ref = 1;
    port = 0;
    cId = 0;
    k = 0;
    key = 0;
    keyLen = 0;
}

MainClient::MainClient( char *ip, unsigned short port, int klientId, char *key, unsigned char keyLen )
{
    ref = 1;
    this->ip = ip;
    this->port = port;
    cId = klientId;
    k = 0;
    this->keyLen = keyLen;
    this->key = new char[ keyLen ];
    memcpy( this->key, key, keyLen );
}

// Destruktor
MainClient::~MainClient()
{
    delete[]key;
    if( k )
        disconnect();
}

// Meldet den neuen Client beim Serversystem an. Durch diesen Vorgang erhält der Client eine Id und den Port und die Ip Addresse des Main Servers
bool MainClient::registerSSL( char *ip, unsigned short port )
{
    cs.lock();
    if( cId )
    {
        cs.unlock();
        return 0;
    }
    Network::SSLKlient *klientSSL = new Network::SSLKlient();
    int l = 0;
    if( !klientSSL->verbinde( port, ip ) )
    {
        err = "error while trying to connect to Main SSL Server";
        klientSSL->release();
        cs.unlock();
        return 0;
    }
    klientSSL->sende( "\1", 5 );
    char byte = 0;
    klientSSL->getNachricht( &byte, 1 );
    if( byte == 3 )
    {
        klientSSL->getNachricht( &byte, 1 );
        char *message = new char[ byte + 1 ];
        message[ byte ] = 0;
        klientSSL->getNachricht( message, byte );
        err = "error while register new client server returned: ";
        err += message;
        delete[]message;
        klientSSL->sende( "\3", 1 );
        klientSSL->getNachricht( &byte, 1 );
        klientSSL->trenne();
        klientSSL->release();
        cs.unlock();
        return 0;
    }
    if( byte == 1 )
    {
        klientSSL->getNachricht( (char*)&this->port, 4 );
        klientSSL->getNachricht( (char*)&cId, 4 );
        klientSSL->getNachricht( (char*)&keyLen, 1 );
        this->ip = ip;
        if( keyLen )
        {
            key = new char[ keyLen ];
            klientSSL->getNachricht( key, keyLen );
        }
    }
    klientSSL->sende( "\3", 1 );
    klientSSL->getNachricht( &byte, 1 );
    klientSSL->trenne();
    klientSSL->release();
    cs.unlock();
    return 1;
}

// Verbindet den Client mit dem Server
//  Wird automatisch aufgerufen, falls eine Methode aufgerufen wird, die eine Verbindung erfordert. In diesem Fall wird die Verbindung auch automatisch wieder getrennt.
bool MainClient::connect()
{
    cs.lock();
    if( k )
    {
        cs.unlock();
        return 1;
    }
    k = new Network::Klient();
    int l = 0;
    char *key;
    Keys::getServerKey( &key, l, Keys::MAIN, Keys::SENDEN );
    k->setSendeKey( key, l );
    delete[] key;
    Keys::getServerKey( &key, l, Keys::MAIN, Keys::EMPFANGEN );
    k->setEmpfangKey( key, l );
    delete[] key;
    if( !k->verbinde( port, ip ) )
    {
        err = "error while trying to connect to Main Server";
        k = k->release();
        cs.unlock();
        return 0;
    }
    k->sende( "\0", 1 ); // Verschlüsselung aktivieren
    k->sendeEncrypted( "\1", 1 );
    k->sendeEncrypted( (char*)&cId, 4 );
    char serverReturn = 0;
    k->getNachrichtEncrypted( &serverReturn, 1 );
    if( serverReturn == 3 )
    {
        k->getNachrichtEncrypted( &serverReturn, 1 );
        char *message = new char[ serverReturn + 1 ];
        message[ serverReturn ] = 0;
        k->getNachrichtEncrypted( message, serverReturn );
        err = "error while trying to identify registered client server returned: ";
        err += message;
        delete[] message;
        k->sendeEncrypted( "\3", 1 );
        k->getNachrichtEncrypted( &serverReturn, 1 );
        k->trenne();
        k = k->release();
        cs.unlock();
        return 0;
    }
    else
    {
        k->setSendeKey( this->key, keyLen );
        k->setEmpfangKey( this->key, keyLen );
        cs.unlock();
        return 1;
    }
}

// Erzeugt einen Erhaltungs Server Client
//  Gibt bei misserfolg 0 zurück
ErhaltungServerClient *MainClient::createErhaltungServerClient()
{
    cs.lock();
    bool connected = k != 0;
    if( !connected )
        connect();
    if( !k )
    {
        err = "no connection to Main Server";
        cs.unlock();
        return 0;
    }
    k->sendeEncrypted( "\6\x8", 2 );
    char byte = 0;
    k->getNachrichtEncrypted( &byte, 1 );
    if( byte == 2 )
    {
        unsigned char lsIp[ 4 ];
        k->getNachrichtEncrypted( (char *)lsIp, 4 );
        unsigned short lsPort = 0;
        k->getNachrichtEncrypted( (char*)&lsPort, 2 );
        Framework::Text ipT;
        ipT += (int)lsIp[ 0 ];
        ipT += ".";
        ipT += (int)lsIp[ 1 ];
        ipT += ".";
        ipT += (int)lsIp[ 2 ];
        ipT += ".";
        ipT += (int)lsIp[ 3 ];
        if( !connected )
            disconnect();
        cs.unlock();
        return new ErhaltungClient( cId, lsPort, ipT, key, keyLen );
    }
    else if( byte == 3 )
    {
        k->getNachrichtEncrypted( &byte, 1 );
        char *f = new char[ byte + 1 ];
        f[ byte ] = 0;
        k->getNachrichtEncrypted( f, byte );
        err = "error while requesting ErhaltungServer server returned: ";
        err += f;
        delete[]f;
    }
    if( !connected )
        disconnect();
    cs.unlock();
    return 0;
}

// Erzeugt einen Patch Server Client
//  Gibt bei misserfolg 0 zurück
PatchServerClient *MainClient::createPatchServerClient()
{
    cs.lock();
    bool connected = k != 0;
    if( !connected )
        connect();
    if( !k )
    {
        err = "no connection to Main Server";
        cs.unlock();
        return 0;
    }
    k->sendeEncrypted( "\6\2", 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 PatchClient( 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 PatchServer server returned: ";
        err += f;
        delete[]f;
    }
    if( !connected )
        disconnect();
    cs.unlock();
    return 0;
}

// Erzeugt einen News Server Client
//  Gibt bei misserfolg 0 zurück
NewsServerClient *MainClient::createNewsServerClient()
{
    cs.lock();
    bool connected = k != 0;
    if( !connected )
        connect();
    if( !k )
    {
        err = "no connection to Main Server";
        cs.unlock();
        return 0;
    }
    k->sendeEncrypted( "\6\x9", 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 NewsClient( 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 NewsServer server returned: ";
        err += f;
        delete[]f;
    }
    if( !connected )
        disconnect();
    cs.unlock();
    return 0;
}

// Erzeugt einen Register Server Client
//  Gibt bei misserfolg 0 zurück
RegisterServerClient *MainClient::createRegisterServerClient()
{

}

// Erzeugt einen Login Server Client
//  Gibt bei misserfolg 0 zurück
LoginServerClient *MainClient::createLoginServerClient()
{

}

// Erzeugt einen Information Server Client
//  Gibt bei misserfolg 0 zurück
InformationServerClient *MainClient::createInformationServerClient()
{

}

// Erzeugt einen Chat Server Client
//  Gibt bei misserfolg 0 zurück
ChatServerClient *MainClient::createChatServerClient()
{

}

// Erzeugt einen Shop Server Client
//  Gibt bei misserfolg 0 zurück
ShopServerClient *MainClient::createShopServerClient()
{

}

// Erzeugt einen Anmeldung Server Client
//  Gibt bei misserfolg 0 zurück
AnmeldungServerClient *MainClient::createAnmeldungServerClient()
{

}

// Erzeugt einen Minigame Server Client
//  Gibt bei misserfolg 0 zurück
MinigameServerClient *MainClient::createMinigameServerClient()
{

}

// Trennt die Verbindung zum Server. Muss nur aufgerufen werden, wenn vorher manuell connect aufgerufen wurde
bool MainClient::disconnect()
{
    cs.lock();
    if( !k )
    {
        cs.unlock();
        return 1;
    }
    char serverReturn = 0;
    k->sendeEncrypted( "\3", 1 );
    k->getNachrichtEncrypted( &serverReturn, 1 );
    k->trenne();
    k = k->release();
    cs.unlock();
    return 1;
}

// Meldet den Client vom Server ab. Alle zuvor von diesem Client erzeugten Clients werden durch diesen Vorgang unbrauchbar
bool MainClient::unregister()
{
    cs.lock();
    bool connected = k != 0;
    if( !connected )
        connect();
    if( !k )
    {
        err = "no connection to Main Server";
        cs.unlock();
        return 0;
    }
    k->sendeEncrypted( "\7", 1 );
    char serverReturn = 0;
    k->getNachrichtEncrypted( &serverReturn, 1 );
    if( serverReturn == 3 )
    {
        k->getNachrichtEncrypted( &serverReturn, 1 );
        char *message = new char[ serverReturn + 1 ];
        message[ serverReturn ] = 0;
        k->getNachrichtEncrypted( message, serverReturn );
        err = "error while trying to unregistere client server returned: ";
        err += message;
        delete[] message;
        if( !connected )
            disconnect();
        cs.unlock();
        return 0;
    }
    disconnect();
    cId = 0;
    delete key;
    key = 0;
    keyLen = 0;
    port = 0;
    ip = "";
    cs.unlock();
    return 1;
}

// Gibt die dem Client zugewiesene Id zurück.
//  sollte erst nach dem Aufruf von registerSSL verwendet werden.
int MainClient::getClientId() const
{
    return cId;
}

// Gibt die Ip Adresse des dem Client zugewiesenen Main Servers zurück.
//  sollte erst nach dem Aufruf von registerSSL verwendet werden.
Framework::Text *MainClient::getServerIp() const
{
    return new Text( ip.getText() );
}

// Gibt den Port des dem Client zugewiesenen Main Servers zurück.
//  sollte erst nach dem Aufruf von registerSSL verwendet werden.
unsigned short MainClient::getServerPort() const
{
    return port;
}

// Gibt den Zeiger auf den Schlüssel zurück
//  sollte erst nach dem Aufruf von registerSSL verwendet werden.
char *MainClient::zKey() const
{
    return key;
}

// Gibt die Länge des Schlüssels zurück
//  sollte erst nach dem Aufruf von registerSSL verwendet werden.
unsigned char MainClient::getKeyLen() const
{
    return keyLen;
}

// gibt den Letzten Fehlertext zuück
//  sollte erst aufgerufen werden, nachdem eine andere aufgerufene Methode fehlgeschlagen ist
char *MainClient::getLetzterFehler() const
{
    return err;
}

// Erhöht den Reference Counter um 1 un gibt this zurück
MainServerClient *MainClient::getThis()
{
    ref++;
    return this;
}

// Verringert den Reference Counter um 1 und gibt 0 zurück.
//  Falls der Reference Counter nach dem Aufruf auf 0 ist löscht sich das Objekt selbst 
MainServerClient *MainClient::release()
{
    if( !--ref )
        delete this;
    return 0;
}