KSG-Client/KSGClient/Netzwerk/Klients/AnmeldungK.cpp

#include "../KSGKlient.h"
#include "../KSGServer.h"
#include "../Keys.h"
#include <Globals.h>

// Inhalt der AnmeldungKlient Klasse aus KSGKlient.h
// Konstruktor
AnmeldungKlient::AnmeldungKlient()
{
    verbunden = 0;
    klient = 0;
    fehler = new Text( "" );
    spielHistorie = 0;
    klientId = getKlientId();
    ref = 1;
}

// Destruktor
AnmeldungKlient::~AnmeldungKlient()
{
    cs.lock();
    if( klient )
    {
        char serverReturn = 0;
        if( verbunden )
        {
            klient->sendeEncrypted( "\4", 1 );
            klient->getNachrichtEncrypted( &serverReturn, 1 );
            if( serverReturn == 3 )
            {
                char län = 0;
                klient->getNachrichtEncrypted( &län, 1 );
                char *nachricht = new char[ län + 1 ];
                nachricht[ län ] = 0;
                klient->getNachrichtEncrypted( nachricht, län );
                delete[]nachricht;
            }
            klient->sendeEncrypted( "\3", 1 );
            klient->getNachrichtEncrypted( &serverReturn, 1 );
            klient->trenne();
        }
        else
        {
            int keyLen = 0;
            char *key = 0;
            Keys::getServerKey( &key, keyLen, Keys::ANMELDUNG, Keys::SENDEN );
            klient->setSendeKey( key, keyLen );
            delete[] key;
            Keys::getServerKey( &key, keyLen, Keys::ANMELDUNG, Keys::EMPFANGEN );
            klient->setEmpfangKey( key, keyLen );
            delete[] key;
            klient->verbinde( klient->getServerPort(), klient->getServerIp() );
            klient->sendeEncrypted( "\1", 1 );
            klient->sendeEncrypted( (char*)&klientId, 4 );
            klient->getNachrichtEncrypted( &serverReturn, 1 );
            if( serverReturn == 3 )
            {
                char län = 0;
                klient->getNachrichtEncrypted( &län, 1 );
                char *nachricht = new char[ län + 1 ];
                nachricht[ län ] = 0;
                klient->getNachrichtEncrypted( nachricht, län );
                delete[]nachricht;
            }
            else
            {
                char *sl = 0;
                char slLän = getSchlüssel( &sl );
                klient->setSendeKey( sl, slLän );
                klient->setEmpfangKey( sl, slLän );
                delete[] sl;
                klient->sendeEncrypted( "\4", 1 );
                klient->getNachrichtEncrypted( &serverReturn, 1 );
                if( serverReturn == 3 )
                {
                    char län = 0;
                    klient->getNachrichtEncrypted( &län, 1 );
                    char *nachricht = new char[ län + 1 ];
                    nachricht[ län ] = 0;
                    klient->getNachrichtEncrypted( nachricht, län );
                    delete[]nachricht;
                }
            }
            klient->sendeEncrypted( "\3", 1 );
            klient->getNachrichtEncrypted( &serverReturn, 1 );
            klient->trenne();
        }
        klient = klient->release();
    }
    fehler = fehler->release();
    cs.unlock();
}

// nicht constant
bool AnmeldungKlient::verbinde() // verbindet ich mit dem Chat Server
{
    cs.lock();
    if( verbunden )
    {
        cs.unlock();
        return 1;
    }
    spielHistorie = 0;
    if( !klient )
    {
        char *msIp = getMainServerIp();
        unsigned short msPort = getMainServerPort();
        Framework::logLine( "Verbinung mit Main Server wird hergestellt..." );
        klient = new Klient();
        int keyLen = 0;
        char *key = 0;
        Keys::getServerKey( &key, keyLen, Keys::MAIN, Keys::SENDEN );
        klient->setSendeKey( key, keyLen );
        delete[] key;
        Keys::getServerKey( &key, keyLen, Keys::MAIN, Keys::EMPFANGEN );
        klient->setEmpfangKey( key, keyLen );
        delete[] key;
        if( !klient->verbinde( msPort, msIp ) )
        {
            Framework::logLine( "ERROR: Server nicht erreichbar." );
            fehler->setText( "Fehler beim verbinden mit dem Main Server. Bitte versuche es Später erneut." );
            klient = klient->release();
            delete[]msIp;
            cs.unlock();
            return 0;
        }
        delete[]msIp;
        klient->sende( "\0", 1 ); // Verschlüsselung aktivieren
        klient->sendeEncrypted( "\1", 1 );
        klient->sendeEncrypted( (char*)&klientId, 4 );
        char serverReturn = 0;
        klient->getNachrichtEncrypted( &serverReturn, 1 );
        if( serverReturn == 3 )
        {
            char län = 0;
            klient->getNachrichtEncrypted( &län, 1 );
            char *nachricht = new char[ län + 1 ];
            nachricht[ län ] = 0;
            klient->getNachrichtEncrypted( nachricht, län );
            fehler->setText( nachricht );
            Framework::logLine( Text( "ERROR: " ) += nachricht );
            delete[]nachricht;
            klient->sendeEncrypted( "\3", 1 );
            klient->getNachrichtEncrypted( &serverReturn, 1 );
            klient->trenne();
            klient = klient->release();
            cs.unlock();
            return 0;
        }
        char *sl = 0;
        char slLän = getSchlüssel( &sl );
        klient->setSendeKey( sl, slLän );
        klient->setEmpfangKey( sl, slLän );
        delete[] sl;
        klient->sendeEncrypted( "\6\6", 2 );
        char byte = 0;
        klient->getNachrichtEncrypted( &byte, 1 );
        if( byte == 2 )
        {
            unsigned char lsIp[ 4 ];
            klient->getNachrichtEncrypted( (char *)lsIp, 4 );
            unsigned short lsPort = 0;
            klient->getNachrichtEncrypted( (char*)&lsPort, 2 );
            klient->sendeEncrypted( "\3", 1 );
            klient->getNachrichtEncrypted( &serverReturn, 1 );
            klient->trenne();
            Text *lsIpT = new Text( "" );
            lsIpT->append( (int)lsIp[ 0 ] );
            lsIpT->append( "." );
            lsIpT->append( (int)lsIp[ 1 ] );
            lsIpT->append( "." );
            lsIpT->append( (int)lsIp[ 2 ] );
            lsIpT->append( "." );
            lsIpT->append( (int)lsIp[ 3 ] );
            Framework::logLine( ( ( Text( "Zugeteilter Anmeldung Server:" ) += lsIpT->getText() ) += ":" ) += lsPort );
            int keyLen = 0;
            char *key = 0;
            Keys::getServerKey( &key, keyLen, Keys::ANMELDUNG, Keys::SENDEN );
            klient->setSendeKey( key, keyLen );
            delete[] key;
            Keys::getServerKey( &key, keyLen, Keys::ANMELDUNG, Keys::EMPFANGEN );
            klient->setEmpfangKey( key, keyLen );
            delete[] key;
            klient->verbinde( lsPort, lsIpT->getText() );
            lsIpT = lsIpT->release();
            klient->sendeEncrypted( "\3", 1 );
            klient->getNachrichtEncrypted( &serverReturn, 1 );
            klient->trenne();
        }
        if( byte == 3 )
        {
            klient->getNachrichtEncrypted( &byte, 1 );
            char *f = new char[ byte + 1 ];
            f[ byte ] = 0;
            klient->getNachrichtEncrypted( f, byte );
            fehler->setText( f );
            Framework::logLine( Text( "ERROR: " ) += f );
            delete[]f;
            klient->sendeEncrypted( "\3", 1 );
            klient->getNachrichtEncrypted( &serverReturn, 1 );
            klient->trenne();
            klient = klient->release();
            cs.unlock();
            return 0;
        }
    }
    Framework::logLine( "Verbinung mit Anmeldung Server wird hergestellt..." );
    int keyLen = 0;
    char *key = 0;
    Keys::getServerKey( &key, keyLen, Keys::ANMELDUNG, Keys::SENDEN );
    klient->setSendeKey( key, keyLen );
    delete[] key;
    Keys::getServerKey( &key, keyLen, Keys::ANMELDUNG, Keys::EMPFANGEN );
    klient->setEmpfangKey( key, keyLen );
    delete[] key;
    if( klient->verbinde( klient->getServerPort(), klient->getServerIp() ) )
    {
        if( klient->sendeEncrypted( "\1", 1 ) )
        {
            klient->sendeEncrypted( (char*)&klientId, 4 );
            char serverReturn = 0;
            klient->getNachrichtEncrypted( &serverReturn, 1 );
            if( serverReturn == 3 )
            {
                char byte = 0;
                klient->getNachrichtEncrypted( &byte, 1 );
                char *f = new char[ byte + 1 ];
                f[ byte ] = 0;
                klient->getNachrichtEncrypted( f, byte );
                fehler->setText( f );
                Framework::logLine( Text( "ERROR: " ) += f );
                delete[]f;
                klient->sendeEncrypted( "\3", 1 );
                klient->getNachrichtEncrypted( &serverReturn, 1 );
                klient->trenne();
                cs.unlock();
                return 0;
            }
            char *sl = 0;
            char slLän = getSchlüssel( &sl );
            klient->setSendeKey( sl, slLän );
            klient->setEmpfangKey( sl, slLän );
            delete[] sl;
            verbunden = 1;
            cs.unlock();
            Framework::logLine( "Erfolgreich mit Anmeldung Server verbunden." );
            return 1;
        }
        else
        {
            Framework::logLine( "ERROR: Senden zum Server nicht erfolgreich." );
            fehler->setText( "Der dir zugewiesene Anmeldung Server hat die Verbindung abgebrochen. Bitte versuche es Später erneut." );
            klient = klient->release();
        }
    }
    else
    {
        Framework::logLine( "ERROR: Server nicht erreichbar." );
        fehler->setText( "Der dir zugewiesene Anmeldung Server antwortet nicht. Bitte versuche es Später erneut." );
        klient = klient->release();
    }
    cs.unlock();
    return 0;
}

int AnmeldungKlient::gruppeErstellen( int karteId ) // erstellt eine gruppe
{
    if( !verbunden )
        verbinde();
    if( !verbunden )
        return 0;
    cs.lock();
    klient->sendeEncrypted( "\5", 1 );
    char serverReturn = 0;
    klient->getNachrichtEncrypted( &serverReturn, 1 );
    if( serverReturn == 3 )
    {
        char län = 0;
        klient->getNachrichtEncrypted( &län, 1 );
        char *message = new char[ län + 1 ];
        message[ län ] = 0;
        klient->getNachrichtEncrypted( message, län );
        fehler->setText( message );
        delete[] message;
        cs.unlock();
        return 0;
    }
    klient->sendeEncrypted( (char*)&karteId, 4 );
    klient->getNachrichtEncrypted( &serverReturn, 1 );
    if( serverReturn == 3 )
    {
        char län = 0;
        klient->getNachrichtEncrypted( &län, 1 );
        char *message = new char[ län + 1 ];
        message[ län ] = 0;
        klient->getNachrichtEncrypted( message, län );
        fehler->setText( message );
        delete[] message;
        cs.unlock();
        return 0;
    }
    int gruppeId = 0;
    klient->getNachrichtEncrypted( (char*)&gruppeId, 4 );
    cs.unlock();
    return gruppeId;
}

bool AnmeldungKlient::gruppeBetreten( int gruppeId, Array< int > *mitglieder, int *anzahl ) // betritt Gruppe
{
    if( !verbunden )
        verbinde();
    if( !verbunden )
        return 0;
    cs.lock();
    klient->sendeEncrypted( "\x6", 1 );
    char serverReturn = 0;
    klient->getNachrichtEncrypted( &serverReturn, 1 );
    if( serverReturn == 3 )
    {
        char län = 0;
        klient->getNachrichtEncrypted( &län, 1 );
        char *message = new char[ län + 1 ];
        message[ län ] = 0;
        klient->getNachrichtEncrypted( message, län );
        fehler->setText( message );
        delete[] message;
        cs.unlock();
        return 0;
    }
    klient->sendeEncrypted( (char*)&gruppeId, 4 );
    klient->getNachrichtEncrypted( &serverReturn, 1 );
    if( serverReturn == 3 )
    {
        char län = 0;
        klient->getNachrichtEncrypted( &län, 1 );
        char *message = new char[ län + 1 ];
        message[ län ] = 0;
        klient->getNachrichtEncrypted( message, län );
        fehler->setText( message );
        delete[] message;
        cs.unlock();
        return 0;
    }
    klient->getNachrichtEncrypted( (char*)anzahl, 4 );
    for( int i = 0; i < *anzahl; i++ )
    {
        int id = 0;
        klient->getNachrichtEncrypted( (char*)&id, 4 );
        mitglieder->add( id, i );
    }
    cs.unlock();
    return 1;
}

bool AnmeldungKlient::gruppeVerlassen( int gruppeId ) // Verlässt die gruppe
{
    if( !verbunden )
        verbinde();
    if( !verbunden )
        return 0;
    cs.lock();
    klient->sendeEncrypted( "\x7", 1 );
    char serverReturn = 0;
    klient->getNachrichtEncrypted( &serverReturn, 1 );
    if( serverReturn == 3 )
    {
        char län = 0;
        klient->getNachrichtEncrypted( &län, 1 );
        char *message = new char[ län + 1 ];
        message[ län ] = 0;
        klient->getNachrichtEncrypted( message, län );
        fehler->setText( message );
        delete[] message;
        cs.unlock();
        return 0;
    }
    klient->sendeEncrypted( (char*)&gruppeId, 4 );
    klient->getNachrichtEncrypted( &serverReturn, 1 );
    if( serverReturn == 3 )
    {
        char län = 0;
        klient->getNachrichtEncrypted( &län, 1 );
        char *message = new char[ län + 1 ];
        message[ län ] = 0;
        klient->getNachrichtEncrypted( message, län );
        fehler->setText( message );
        delete[] message;
        cs.unlock();
        return 0;
    }
    cs.unlock();
    return 1;
}

bool AnmeldungKlient::gruppeAnmelden( int gruppeId ) // meldet gruppe an
{
    if( !verbunden )
        verbinde();
    if( !verbunden )
        return 0;
    cs.lock();
    klient->sendeEncrypted( "\x9", 1 );
    char serverReturn = 0;
    klient->getNachrichtEncrypted( &serverReturn, 1 );
    if( serverReturn == 3 )
    {
        char län = 0;
        klient->getNachrichtEncrypted( &län, 1 );
        char *message = new char[ län + 1 ];
        message[ län ] = 0;
        klient->getNachrichtEncrypted( message, län );
        fehler->setText( message );
        delete[] message;
        cs.unlock();
        return 0;
    }
    klient->sendeEncrypted( (char*)&gruppeId, 4 );
    klient->getNachrichtEncrypted( &serverReturn, 1 );
    if( serverReturn == 3 )
    {
        char län = 0;
        klient->getNachrichtEncrypted( &län, 1 );
        char *message = new char[ län + 1 ];
        message[ län ] = 0;
        klient->getNachrichtEncrypted( message, län );
        fehler->setText( message );
        delete[] message;
        cs.unlock();
        return 0;
    }
    cs.unlock();
    return 1;
}

bool AnmeldungKlient::gruppeAbmelden( int gruppeId ) // meldet gruppe ab
{
    if( !verbunden )
        verbinde();
    if( !verbunden )
        return 0;
    cs.lock();
    klient->sendeEncrypted( "\xA", 1 );
    char serverReturn = 0;
    klient->getNachrichtEncrypted( &serverReturn, 1 );
    if( serverReturn == 3 )
    {
        char län = 0;
        klient->getNachrichtEncrypted( &län, 1 );
        char *message = new char[ län + 1 ];
        message[ län ] = 0;
        klient->getNachrichtEncrypted( message, län );
        fehler->setText( message );
        delete[] message;
        cs.unlock();
        return 0;
    }
    klient->sendeEncrypted( (char*)&gruppeId, 4 );
    klient->getNachrichtEncrypted( &serverReturn, 1 );
    if( serverReturn == 3 )
    {
        char län = 0;
        klient->getNachrichtEncrypted( &län, 1 );
        char *message = new char[ län + 1 ];
        message[ län ] = 0;
        klient->getNachrichtEncrypted( message, län );
        fehler->setText( message );
        delete[] message;
        cs.unlock();
        return 0;
    }
    cs.unlock();
    return 1;
}

bool AnmeldungKlient::gruppeSpielerEinladen( int accountId, int gruppeId ) // läht Spieler ein die Gruppe zu betreten
{
    if( !verbunden )
        verbinde();
    if( !verbunden )
        return 0;
    cs.lock();
    klient->sendeEncrypted( "\xB", 1 );
    char serverReturn = 0;
    klient->getNachrichtEncrypted( &serverReturn, 1 );
    if( serverReturn == 3 )
    {
        char län = 0;
        klient->getNachrichtEncrypted( &län, 1 );
        char *message = new char[ län + 1 ];
        message[ län ] = 0;
        klient->getNachrichtEncrypted( message, län );
        fehler->setText( message );
        delete[] message;
        cs.unlock();
        return 0;
    }
    klient->sendeEncrypted( (char*)&accountId, 4 );
    klient->sendeEncrypted( (char*)&gruppeId, 4 );
    klient->getNachrichtEncrypted( &serverReturn, 1 );
    if( serverReturn == 3 )
    {
        char län = 0;
        klient->getNachrichtEncrypted( &län, 1 );
        char *message = new char[ län + 1 ];
        message[ län ] = 0;
        klient->getNachrichtEncrypted( message, län );
        fehler->setText( message );
        delete[] message;
        cs.unlock();
        return 0;
    }
    cs.unlock();
    return 1;
}

bool AnmeldungKlient::gruppeEinladungAbbrechen( int accountId, int gruppeId ) // bricht einladung ab
{
    if( !verbunden )
        verbinde();
    if( !verbunden )
        return 0;
    cs.lock();
    klient->sendeEncrypted( "\x11", 1 );
    char serverReturn = 0;
    klient->getNachrichtEncrypted( &serverReturn, 1 );
    if( serverReturn == 3 )
    {
        char län = 0;
        klient->getNachrichtEncrypted( &län, 1 );
        char *message = new char[ län + 1 ];
        message[ län ] = 0;
        klient->getNachrichtEncrypted( message, län );
        fehler->setText( message );
        delete[] message;
        cs.unlock();
        return 0;
    }
    klient->sendeEncrypted( (char*)&gruppeId, 4 );
    klient->sendeEncrypted( (char*)&accountId, 4 );
    klient->getNachrichtEncrypted( &serverReturn, 1 );
    if( serverReturn == 3 )
    {
        char län = 0;
        klient->getNachrichtEncrypted( &län, 1 );
        char *message = new char[ län + 1 ];
        message[ län ] = 0;
        klient->getNachrichtEncrypted( message, län );
        fehler->setText( message );
        delete[] message;
        cs.unlock();
        return 0;
    }
    cs.unlock();
    return 1;
}

bool AnmeldungKlient::gruppeEinladungAblehnen( int gruppeId ) // Einladung zur Gruppe ablehnen
{
    if( !verbunden )
        verbinde();
    if( !verbunden )
        return 0;
    cs.lock();
    klient->sendeEncrypted( "\x12", 1 );
    char serverReturn = 0;
    klient->getNachrichtEncrypted( &serverReturn, 1 );
    if( serverReturn == 3 )
    {
        char län = 0;
        klient->getNachrichtEncrypted( &län, 1 );
        char *message = new char[ län + 1 ];
        message[ län ] = 0;
        klient->getNachrichtEncrypted( message, län );
        fehler->setText( message );
        delete[] message;
        cs.unlock();
        return 0;
    }
    klient->sendeEncrypted( (char*)&gruppeId, 4 );
    klient->getNachrichtEncrypted( &serverReturn, 1 );
    if( serverReturn == 3 )
    {
        char län = 0;
        klient->getNachrichtEncrypted( &län, 1 );
        char *message = new char[ län + 1 ];
        message[ län ] = 0;
        klient->getNachrichtEncrypted( message, län );
        fehler->setText( message );
        delete[] message;
        cs.unlock();
        return 0;
    }
    cs.unlock();
    return 1;
}

bool AnmeldungKlient::kickSpielerAusGruppe( int accountId, int gruppeId ) // wirft Spieler aus Gruppe
{
    if( !verbunden )
        verbinde();
    if( !verbunden )
        return 0;
    cs.lock();
    klient->sendeEncrypted( "\xC", 1 );
    char serverReturn = 0;
    klient->getNachrichtEncrypted( &serverReturn, 1 );
    if( serverReturn == 3 )
    {
        char län = 0;
        klient->getNachrichtEncrypted( &län, 1 );
        char *message = new char[ län + 1 ];
        message[ län ] = 0;
        klient->getNachrichtEncrypted( message, län );
        fehler->setText( message );
        delete[] message;
        cs.unlock();
        return 0;
    }
    klient->sendeEncrypted( (char*)&accountId, 4 );
    klient->sendeEncrypted( (char*)&gruppeId, 4 );
    klient->getNachrichtEncrypted( &serverReturn, 1 );
    if( serverReturn == 3 )
    {
        char län = 0;
        klient->getNachrichtEncrypted( &län, 1 );
        char *message = new char[ län + 1 ];
        message[ län ] = 0;
        klient->getNachrichtEncrypted( message, län );
        fehler->setText( message );
        delete[] message;
        cs.unlock();
        return 0;
    }
    cs.unlock();
    return 1;
}

bool AnmeldungKlient::gruppeSpielStarten( int gruppeId, bool spielStarten ) // startet das Spiel der Gruppe
{
    if( !verbunden )
        verbinde();
    if( !verbunden )
        return 0;
    cs.lock();
    klient->sendeEncrypted( "\x10", 1 );
    char serverReturn = 0;
    klient->getNachrichtEncrypted( &serverReturn, 1 );
    if( serverReturn == 3 )
    {
        char län = 0;
        klient->getNachrichtEncrypted( &län, 1 );
        char *message = new char[ län + 1 ];
        message[ län ] = 0;
        klient->getNachrichtEncrypted( message, län );
        fehler->setText( message );
        delete[] message;
        cs.unlock();
        return 0;
    }
    klient->sendeEncrypted( (char*)&gruppeId, 4 );
    klient->sendeEncrypted( (char*)&spielStarten, 1 );
    klient->getNachrichtEncrypted( &serverReturn, 1 );
    if( serverReturn == 3 )
    {
        char län = 0;
        klient->getNachrichtEncrypted( &län, 1 );
        char *message = new char[ län + 1 ];
        message[ län ] = 0;
        klient->getNachrichtEncrypted( message, län );
        fehler->setText( message );
        delete[] message;
        cs.unlock();
        return 0;
    }
    cs.unlock();
    return 1;
}

bool AnmeldungKlient::gruppeNachricht( int gruppeId, char *nachricht ) // nachricht an gruppe senden
{
    if( !verbunden )
        verbinde();
    if( !verbunden )
        return 0;
    char län = textLength( nachricht );
    if( !län )
        return 1;
    cs.lock();
    klient->sendeEncrypted( "\xD", 1 );
    char serverReturn = 0;
    klient->getNachrichtEncrypted( &serverReturn, 1 );
    if( serverReturn == 3 )
    {
        char län = 0;
        klient->getNachrichtEncrypted( &län, 1 );
        char *message = new char[ län + 1 ];
        message[ län ] = 0;
        klient->getNachrichtEncrypted( message, län );
        fehler->setText( message );
        delete[] message;
        cs.unlock();
        return 0;
    }
    klient->sendeEncrypted( (char*)&gruppeId, 4 );
    klient->sendeEncrypted( (char*)&län, 1 );
    klient->sendeEncrypted( nachricht, län );
    klient->getNachrichtEncrypted( &serverReturn, 1 );
    if( serverReturn == 3 )
    {
        char län = 0;
        klient->getNachrichtEncrypted( &län, 1 );
        char *message = new char[ län + 1 ];
        message[ län ] = 0;
        klient->getNachrichtEncrypted( message, län );
        fehler->setText( message );
        delete[] message;
        cs.unlock();
        return 0;
    }
    cs.unlock();
    return 1;
}

bool AnmeldungKlient::anmelden( int karteId ) // betritt warteschlange
{
    if( !verbunden )
        verbinde();
    if( !verbunden )
        return 0;
    cs.lock();
    klient->sendeEncrypted( "\xE", 1 );
    char serverReturn = 0;
    klient->getNachrichtEncrypted( &serverReturn, 1 );
    if( serverReturn == 3 )
    {
        char län = 0;
        klient->getNachrichtEncrypted( &län, 1 );
        char *message = new char[ län + 1 ];
        message[ län ] = 0;
        klient->getNachrichtEncrypted( message, län );
        fehler->setText( message );
        delete[] message;
        cs.unlock();
        return 0;
    }
    klient->sendeEncrypted( (char*)&karteId, 4 );
    klient->getNachrichtEncrypted( &serverReturn, 1 );
    if( serverReturn == 3 )
    {
        char län = 0;
        klient->getNachrichtEncrypted( &län, 1 );
        char *message = new char[ län + 1 ];
        message[ län ] = 0;
        klient->getNachrichtEncrypted( message, län );
        fehler->setText( message );
        delete[] message;
        cs.unlock();
        return 0;
    }
    cs.unlock();
    return 1;
}

bool AnmeldungKlient::abmelden() // verlässt warteschlange
{
    if( !verbunden )
        verbinde();
    if( !verbunden )
        return 0;
    cs.lock();
    klient->sendeEncrypted( "\xF", 1 );
    char serverReturn = 0;
    klient->getNachrichtEncrypted( &serverReturn, 1 );
    if( serverReturn == 3 )
    {
        char län = 0;
        klient->getNachrichtEncrypted( &län, 1 );
        char *message = new char[ län + 1 ];
        message[ län ] = 0;
        klient->getNachrichtEncrypted( message, län );
        fehler->setText( message );
        delete[] message;
        cs.unlock();
        return 0;
    }
    cs.unlock();
    return 1;
}

bool AnmeldungKlient::keepAlive() // Erhält die Verbindung aufrecht
{
    if( !verbunden )
        return 0;
    char res = 0;
    if( !cs.tryLock() )
        return 1;
    Framework::logLine( "Verbindungstest zum Anmeldung Server..." );
    bool ok = klient->sendeEncrypted( "\x13", 1 );
    ok &= klient->getNachrichtEncrypted( &res, 1 );
    cs.unlock();
    if( res != 1 || !ok )
    {
        Framework::logLine( "Verbindungsabbruch." );
        trenne();
    }
    else
        Framework::logLine( "Verbindung besteht." );
    return res == 1;
}

bool AnmeldungKlient::trenne() // trennt sich von dem Chat Server
{
    if( !verbunden )
        return 1;
    cs.lock();
    Framework::logLine( "Verbindung zum Anmeldung Server wird getrennt..." );
    klient->sendeEncrypted( "\3", 1 );
    char serverReturn = 0;
    klient->getNachrichtEncrypted( &serverReturn, 1 );
    klient->trenne();
    verbunden = 0;
    klient->trenne();
    cs.unlock();
    return 1;
}

// constant
bool AnmeldungKlient::istVerbunden() const // prüft, ob mit Chat Server verbunden
{
    return verbunden;
}

char *AnmeldungKlient::getLetzterFehler() const // gibt den Letzten Fehlertext zuück
{
    return fehler->getText();
}

// Reference Counting
AnmeldungKlient *AnmeldungKlient::getThis()
{
    ref++;
    return this;
}

AnmeldungKlient *AnmeldungKlient::release()
{
    ref--;
    if( !ref )
        delete this;
    return 0;
}