ChatServer/ChatServer/ChatServer.cpp

#include "ChatServer.h"
#include <iostream>
#include <Globals.h>
#ifndef WIN32
#include <unistd.h>
#define Sleep( x )   usleep( (x) * 1000 )
#endif

// Inhalt der ChatServer Klasse aus ChatServer.h
// Konstruktor 
ChatServer::ChatServer( InitDatei* zIni )
    : Thread()
{
    Network::Start( 100 );
    std::cout << "CS: Verbindung mit Datenbank wird hergestellt...\n";
    db = new CSDatenbank( zIni );
    klients = new RCArray< CSKlient >();
    empfangen = 0;
    gesendet = 0;
    fehler = new Text();
    ini = dynamic_cast<InitDatei*>(zIni->getThis());
    id = *zIni->zWert( "ServerId" );
    server = new Server();
    aServer = new SSLServer();
    aServer->setPrivateKeyPassword( zIni->zWert( "SSLPasswort" )->getText() );
    aServer->setCertificateFile( zIni->zWert( "SSLCert" )->getText() );
    aServer->setPrivateKeyFile( zIni->zWert( "SSLKey" )->getText() );
    std::cout << "CS: Starten des Admin Servers...\n";
    if( !aServer->verbinde( (unsigned short)TextZuInt( ini->zWert( "AdminServerPort" )->getText(), 10 ), 10 ) )
    {
        std::cout << "CS: Der Admin Server konnte nicht gestartet werden. Das Programm wird beendet.\n";
        exit( 1 );
    }
    db->setServerStatus( id, 2 );
    end = 0;
    nichtPausiert = 0;
    if( zIni->zWert( "Aktiv" )->istGleich( "TRUE" ) )
    {
        serverStarten();
        serverFortsetzen();
    }
}

// Destruktor 
ChatServer::~ChatServer()
{
    fehler->release();
    server->trenne();
    server->release();
    aServer->trenne();
    aServer->release();
    ini->release();
    db->release();
    if( klients )
        klients->release();
}

// nicht constant 
void ChatServer::runn()
{
    while( !end && aServer->isConnected() )
    {
        SSLSKlient* klient;
        klient = aServer->getKlient();
        if( end && klient )
        {
            klient->trenne();
            klient = (SSLSKlient*)klient->release();
            Sleep( 1000 );
            return;
        }
        if( !klient )
            continue;
        CSAKlient* clHandle = new CSAKlient( klient, dynamic_cast<ChatServer*>(getThis()) );
        clHandle->start();
    }
}

void ChatServer::thread()
{
    while( server->isConnected() )
    {
        SKlient* klient;
        klient = server->getKlient();
        if( !klient )
            continue;
        Framework::getThreadRegister()->cleanUpClosedThreads();
        CSKlient* clHandle = new CSKlient( klient, dynamic_cast<ChatServer*>(getThis()) );
        cs.lock();
        klients->add( clHandle );
        cs.unlock();
        clHandle->start();
    }
}

void ChatServer::close()
{
    db->setServerStatus( id, 1 );
    server->trenne();
#ifdef WIN32
    warteAufThread( 1000 );
#endif
    cs.lock();
    for( CSKlient* client : *klients )
        client->absturz();
    klients = (RCArray<CSKlient> *)klients->release();
    cs.unlock();
    ende();
    run = 0;
    end = 1;
    Klient* klient = new Klient();
    klient->verbinde( aServer->getPort(), "127.0.0.1" );
    Sleep( 500 );
    aServer->trenne();
    klient->release();
}

bool ChatServer::serverStarten()
{
    if( nichtPausiert )
    {
        fehler->setText( "Der Server konnte nicht gestartet werden: Der Server läuft bereits." );
        return 0;
    }
    if( server )
        server->release();
    server = new Server();
    if( server->verbinde( (unsigned short)TextZuInt( ini->zWert( "ServerPort" )->getText(), 10 ), 10 ) )
    {
        nichtPausiert = 1;
        start();
        return 1;
    }
    else
    {
        serverBeenden();
        fehler->setText( "Der Server konnte nicht gestartet werden: Eventuell ist der Port in benutzung." );
        return 0;
    }
}

bool ChatServer::serverPause()
{
    if( !nichtPausiert )
    {
        fehler->setText( "Der Server konnte nicht pausiert werden: Der Server läuft nicht." );
        return 0;
    }
    if( !db->setServerStatus( id, 2 ) )
    {
        fehler->setText( "Der Server konnte nicht pausiert werden: " );
        fehler->append( db->getLetzterFehler() );
        return 0;
    }
    return 1;
}

bool ChatServer::serverFortsetzen()
{
    if( !nichtPausiert )
    {
        fehler->setText( "Der Server konnte nicht fortgesetzt werden: Der Server läuft nicht." );
        return 0;
    }
    if( !db->setServerStatus( id, 3 ) )
    {
        fehler->setText( "Der Server konnte nicht fortgesetzt werden: " );
        fehler->append( db->getLetzterFehler() );
        return 0;
    }
    return 1;
}

bool ChatServer::serverBeenden()
{
    if( !nichtPausiert )
    {
        fehler->setText( "Der Server konnte nicht beendet werden: Der Server läuft nicht." );
        return 0;
    }
    if( db->serverIstNichtPausiert( id ) )
    {
        fehler->setText( "Der Server konnte nicht beendet werden: Der Server muss erst pausiert werden." );
        return 0;
    }
    nichtPausiert = 0;
    ende();
    if( server )
        server->trenne();
    return 1;
}

bool ChatServer::setMaxKlients( int mc )
{
    if( !db->setMaxClients( id, mc ) )
    {
        fehler->setText( "Die maximale Anzahl der Clients konnte nicht gesetzt werden:\n" );
        fehler->append( db->getLetzterFehler() );
        return 0;
    }
    ini->setWert( "MaxClients", Text() += mc );
    return 1;
}

bool ChatServer::absturzKlient( int klientId )
{
    bool gefunden = 0;
    cs.lock();
    for( int i = 0; i < klients->getEintragAnzahl(); i++ )
    {
        if( klients->z( i )->getKlientNummer() == klientId )
        {
            klients->z( i )->absturz();
            klients->remove( i );
            gefunden = 1;
            i--;
        }
    }
    cs.unlock();
    return gefunden;
}

bool ChatServer::removeAccount( int accId )
{
    bool gefunden = 0;
    cs.lock();
    for( int i = 0; i < klients->getEintragAnzahl(); i++ )
    {
        if( klients->z( i )->getAccountId() == accId )
        {
            klients->remove( i );
            gefunden = 1;
            i--;
        }
    }
    cs.unlock();
    return gefunden;
}

bool ChatServer::removeKlient( int klientId )
{
    bool gefunden = 0;
    cs.lock();
    for( int i = 0; i < klients->getEintragAnzahl(); i++ )
    {
        if( klients->z( i )->getKlientNummer() == klientId )
        {
            klients->z( i )->trenne();
            klients->remove( i );
            gefunden = 1;
            i--;
        }
    }
    cs.unlock();
    return gefunden;
}

bool ChatServer::removeKlient( CSKlient* zKlient )
{
    bool gefunden = 0;
    cs.lock();
    for( int i = 0; i < klients->getEintragAnzahl(); i++ )
    {
        if( klients->z( i ) == zKlient )
        {
            klients->z( i )->trenne();
            klients->remove( i );
            gefunden = 1;
            break;
        }
    }
    cs.unlock();
    return gefunden;
}

void ChatServer::addGesendet( int bytes )
{
    gesendet += bytes;
}

void ChatServer::addEmpfangen( int bytes )
{
    empfangen += bytes;
}

int ChatServer::getKlientStatus( int klientNummer, CSKlient* zKlient )
{
    bool empf = 0;
    bool send = 0;
    cs.lock();
    for( int i = 0; i < klients->getEintragAnzahl(); i++ )
    {
        if( klients->z( i )->getKlientNummer() == klientNummer && klients->z( i ) != zKlient )
        {
            if( klients->z( i )->istEmpfang() )
                empf = 1;
            else
                send = 1;
        }
    }
    cs.unlock();
    if( !empf )
        return 0;
    if( !send )
        return 1;
    return 2;
}

CSKlient* ChatServer::zSendeKlient( int accountId )
{
    CSKlient* ret = 0;
    cs.lock();
    for( int i = 0; i < klients->getEintragAnzahl(); i++ )
    {
        if( klients->z( i )->getAccountId() == accountId && !klients->z( i )->istEmpfang() )
        {
            ret = klients->z( i );
            break;
        }
    }
    cs.unlock();
    return ret;
}

// constant 
bool ChatServer::istAn() const
{
    return db->serverIstNichtPausiert( id );
}

Server* ChatServer::zServer() const
{
    return server;
}

CSDatenbank* ChatServer::zDB() const
{
    return db;
}

bool ChatServer::hatClients() const
{
    return klients->hat( 0 );
}

int ChatServer::getId() const
{
    return id;
}

char* ChatServer::getLetzterFehler() const
{
    return fehler->getText();
}


// Inhalt der CSAKlient Klasse aus ChatServer.h
// Konstruktor 
CSAKlient::CSAKlient( SSLSKlient* klient, ChatServer* cs )
    : Thread()
{
    this->klient = klient;
    name = new Text( "" );
    passwort = new Text( "" );
    adminId = 0;
    this->cs = cs;
}

// Destruktor 
CSAKlient::~CSAKlient()
{
    klient->trenne();
    klient->release();
    cs->release();
    name->release();
    passwort->release();
}

// nicht constant 
void CSAKlient::thread()
{
    while( 1 )
    {
        char c = 0;
        if( !klient->getNachricht( &c, 1 ) )
            break;
        else
        {
            bool br = 0;
            switch( c )
            {
            case 1: // Login
                if( 1 )
                {
                    klient->sende( "\1", 1 );
                    unsigned char nLen = 0;
                    klient->getNachricht( (char*)&nLen, 1 );
                    char* n = new char[ nLen + 1 ];
                    n[ (int)nLen ] = 0;
                    if( nLen )
                        klient->getNachricht( n, nLen );
                    unsigned char pLen = 0;
                    klient->getNachricht( (char*)&pLen, 1 );
                    char* p = new char[ pLen + 1 ];
                    p[ (int)pLen ] = 0;
                    if( pLen )
                        klient->getNachricht( p, pLen );
                    int adminId = cs->zDB()->istAdministrator( n, p );
                    if( adminId )
                    {
                        klient->sende( "\1", 1 );
                        name->setText( n );
                        passwort->setText( p );
                        this->adminId = adminId;
                    }
                    else
                        errorZuKlient( "Falsche Kombination aus Name und Passwort." );
                    delete[] n;
                    delete[] p;
                }
                break;
            case 2: // Logout
                adminId = 0;
                name->setText( "" );
                passwort->setText( "" );
                klient->sende( "\1", 1 );
                break;
            case 3: // Trennen
                br = 1;
                klient->sende( "\1", 1 );
                break;
            case 4: // Server starten
                if( !adminId )
                    errorZuKlient( "Du musst dich einloggen." );
                else
                {
                    if( cs->zDB()->adminHatRecht( adminId, Admin_Recht::CSStarten ) )
                    {
                        if( !cs->serverStarten() )
                        {
                            Text* err = new Text();
                            err->append( cs->getLetzterFehler() );
                            errorZuKlient( err->getText() );
                            err->release();
                        }
                        else
                            klient->sende( "\1", 1 );
                    }
                    else
                        errorZuKlient( "Du bist nicht berechtigt den Server zu starten." );
                }
                break;
            case 5: // Server beenden
                if( !adminId )
                    errorZuKlient( "Du musst dich einloggen." );
                else
                {
                    if( cs->zDB()->adminHatRecht( adminId, Admin_Recht::CSBeenden ) )
                    {
                        if( cs->serverBeenden() )
                            klient->sende( "\1", 1 );
                        else
                        {
                            Text* err = new Text();
                            err->append( cs->getLetzterFehler() );
                            errorZuKlient( err->getText() );
                            err->release();
                        }
                    }
                    else
                        errorZuKlient( "Du bist nicht berechtigt den Server zu beenden." );
                }
                break;
            case 6: // Programm Schließen
                if( !adminId )
                    errorZuKlient( "Du musst dich einloggen." );
                else
                {
                    bool ok = 0;
                    if( cs->isRunning() )
                    {
                        if( cs->zDB()->adminHatRecht( adminId, Admin_Recht::CSBeenden ) )
                        {
                            if( cs->serverBeenden() )
                                ok = 1;
                            else
                            {
                                Text* err = new Text();
                                err->append( cs->getLetzterFehler() );
                                errorZuKlient( err->getText() );
                                err->release();
                            }
                        }
                        else
                            errorZuKlient( "Du bist nicht berechtigt den Server zu beenden." );
                    }
                    else
                        ok = 1;
                    if( ok && cs->hatClients() )
                    {
                        errorZuKlient( "Es sind noch Klients Online. Bitte versuche es später erneut." );
                        break;
                    }
                    if( ok )
                    {
                        klient->sende( "\1", 1 );
                        std::cout << "CS: Der Server wird von Benutzer " << adminId << " heruntergefahren.\n";
                        cs->close();
                        br = 1;
                    }
                }
                break;
            case 7: // Progtamm abstürzen
                if( !adminId )
                    errorZuKlient( "Du musst dich einloggen." );
                else
                {
                    bool ok = 0;
                    if( cs->isRunning() )
                    {
                        if( cs->zDB()->adminHatRecht( adminId, Admin_Recht::CSBeenden ) )
                        {
                            cs->serverBeenden();
                            ok = 1;
                        }
                        else
                            errorZuKlient( "Du bist nicht berechtigt den Server zu beenden." );
                    }
                    else
                        ok = 1;
                    if( ok )
                    {
                        klient->sende( "\1", 1 );
                        std::cout << "CS: Der Server wurde von Benutzer " << adminId << " terminiert.\n";
                        cs->close();
                        br = 1;
                    }
                }
                break;
            case 8: // Status Frage
                if( 1 )
                {
                    char status = 0;
                    if( cs->isRunning() )
                    {
                        status = 1;
                        if( cs->istAn() )
                            status = 2;
                    }
                    klient->sende( "\1", 1 );
                    klient->sende( &status, 1 );
                }
                break;
            case 9: // Server pausieren
                if( !adminId )
                    errorZuKlient( "Du musst dich einloggen." );
                else
                {
                    klient->sende( "\1", 1 );
                    char pause = 0;
                    klient->getNachricht( &pause, 1 );
                    if( cs->zDB()->adminHatRecht( adminId, Admin_Recht::CSPausieren ) )
                    {
                        bool ok = 0;
                        if( pause )
                            ok = cs->serverPause();
                        else
                            ok = cs->serverFortsetzen();
                        if( ok )
                            klient->sende( "\1", 1 );
                        else
                        {
                            Text* err = new Text();
                            err->append( cs->getLetzterFehler() );
                            errorZuKlient( err->getText() );
                            err->release();
                        }
                    }
                    else
                    {
                        if( pause )
                            errorZuKlient( "Du bist nicht berechtigt den Server zu pausieren." );
                        else
                            errorZuKlient( "Du bist nicht berechtigt den Server fortzusetzen." );
                    }
                }
                break;
            case 0xA: // maximale Anzahl der Clients setzen
                if( !adminId )
                    errorZuKlient( "Du musst dich einloggen." );
                else
                {
                    klient->sende( "\1", 1 );
                    int maxC = 0;
                    klient->getNachricht( (char*)&maxC, 4 );
                    if( cs->zDB()->adminHatRecht( adminId, Admin_Recht::CSMCChange ) )
                    {
                        if( cs->setMaxKlients( maxC ) )
                            klient->sende( "\1", 1 );
                        else
                        {
                            Text* err = new Text();
                            err->append( cs->getLetzterFehler() );
                            errorZuKlient( err->getText() );
                            err->release();
                        }
                    }
                    else
                        errorZuKlient( "Du bist nicht berechtigt die maximale Anzahl der Clients zu verändern." );
                }
                break;
            case 0xC: // klient absturtz
                if( 1 )
                {
                    klient->sende( "\1", 1 );
                    int klientId = 0;
                    klient->getNachricht( (char*)&klientId, 4 );
                    if( klientId && cs->absturzKlient( klientId ) )
                        klient->sende( "\1", 1 );
                    else
                        klient->sende( "\0", 1 );
                }
                break;
            default:
                errorZuKlient( "Unbekannte Nachricht!" );
                break;
            }
            if( br )
                break;
            cs->addEmpfangen( klient->getDownloadBytes( 1 ) );
            cs->addGesendet( klient->getUploadBytes( 1 ) );
        }
    }
    cs->addEmpfangen( klient->getDownloadBytes( 1 ) );
    cs->addGesendet( klient->getUploadBytes( 1 ) );
    delete this;
}

void CSAKlient::errorZuKlient( const char* nachricht ) const // sendet eine Fehlernachricht zum Klient
{
    klient->sende( "\3", 1 );
    char len = (char)textLength( nachricht );
    klient->sende( &len, 1 );
    klient->sende( nachricht, len );
}


// Inhalt der CSKlient aus ChatServer.h
// Konstruktor 
CSKlient::CSKlient( SKlient* klient, ChatServer* cs )
    : Thread()
{
    this->klient = klient;
    unsigned char key[ 20 ] = { 78, 20, 190, 133, 10, 175, 51, 96, 62, 1, 180, 194, 126, 50, 211, 154, 105, 227, 22, 101 };
    klient->setSendeKey( (char*)key, 20 );
    klient->setEmpfangKey( (char*)key, 20 );
    klientNummer = 0;
    this->cs = cs;
    accountId = 0;
    empfangen = 1;
}

// Destruktor 
CSKlient::~CSKlient()
{
    cs->addEmpfangen( klient->getDownloadBytes( 1 ) );
    cs->addGesendet( klient->getUploadBytes( 1 ) );
    klient->release();
    cs->release();
}

// nicht constant 
void CSKlient::lock()
{
    ts.lock();
}

void CSKlient::unlock()
{
    ts.unlock();
}

void CSKlient::absturz()
{
#ifdef WIN32
    if( GetCurrentThreadId() != GetThreadId( getThreadHandle() ) )
        ende();
#else
    ende();
#endif
    klient->trenne();
    if( empfangen )
    {
        cs->zDB()->unregisterKlient( klientNummer, cs->getId() );
        MSGWeiterleitung* weiter = new MSGWeiterleitung( dynamic_cast<ChatServer*>(cs->getThis()) );
        weiter->accountOffline( accountId );
        delete weiter;
}
}

void CSKlient::thread()
{
    int unbekannt = 0;
    while( 1 )
    {
        char c = 0;
        if( !klient->getNachrichtEncrypted( &c, 1 ) )
            break;
        else
        {
            bool br = 0;
            switch( c )
            {
            case 1: // Klient identifikation
                klient->getNachrichtEncrypted( (char*)&klientNummer, 4 );
                if( !cs->zDB()->proveKlient( klientNummer, cs->getId() ) )
                {
                    klientNummer = 0;
                    errorZuKlient( "Du bist nicht für diesen Server eingetragen" );
                }
                if( klientNummer )
                {
                    accountId = cs->zDB()->getKlientAccountId( klientNummer );
                    if( !accountId )
                    {
                        errorZuKlient( "Du bist nicht online" );
                        klientNummer = 0;
                    }
                    else
                    {
                        int status = cs->getKlientStatus( klientNummer, this );
                        if( status == 2 )
                        {
                            klientNummer = 0;
                            accountId = 0;
                            errorZuKlient( "Diese Klient Nummer ist bereits verbunden" );
                        }
                        else
                        {
                            Text* key = cs->zDB()->getKlientKey( klientNummer );
                            if( !key )
                                errorZuKlient( "Es konnte kein Schlüssel ermittelt werden." );
                            else
                            {
                                klient->sendeEncrypted( "\1", 1 );
                                klient->setEmpfangKey( *key, key->getLength() );
                                klient->setSendeKey( *key, key->getLength() );
                                key->release();
                                if( status == 1 )
                                {
                                    empfangen = 0;
                                    MSGWeiterleitung* weiter = new MSGWeiterleitung( dynamic_cast<ChatServer*>(cs->getThis()) );
                                    weiter->accountOnline( accountId );
                                    delete weiter;
                                    br = 1;
                                }
                            }
                        }
                    }
                }
                break;
            case 2: // Main / Erhaltung Server message
                if( 1 )
                {
                    char befehl = 0;
                    klient->getNachrichtEncrypted( &befehl, 1 );
                    switch( befehl )
                    {
                    case 2: // klient absturtz
                        if( 1 )
                        {
                            int klientId = 0;
                            klient->getNachrichtEncrypted( (char*)&klientId, 4 );
                            if( klientId && cs->absturzKlient( klientId ) )
                                klient->sendeEncrypted( "\1", 1 );
                            else
                                klient->sendeEncrypted( "\0", 1 );
                        }
                        break;
                    default:
                        errorZuKlient( "Befehl nicht bekannt!" );
                        break;
                    }
                }
                break;
            case 3: // Verbindungsende
                if( 1 )
                {
                    lock();
                    klient->sendeEncrypted( "\1", 1 );
                    unlock();
                    br = 1;
                }
                break;
            case 4: // unregister Klient
                if( !klientNummer )
                {
                    klient->sendeEncrypted( "\0", 1 );
                    CSKlient* c = cs->zSendeKlient( accountId );
                    if( c )
                        c->errorZuKlient( "Du bist nicht Identifiziert." );
                    break;
                }
                cs->zDB()->unregisterKlient( klientNummer, cs->getId() );
                klient->sendeEncrypted( "\1", 1 );
                break;
            case 5: // Server message
                if( 1 )
                {
                    char byte = 0;
                    char res = 1;
                    klient->getNachrichtEncrypted( &byte, 1 );
                    switch( byte )
                    {
                    case 1: // kick Klient
                        if( 1 )
                        {
                            klient->sendeEncrypted( "\1", 1 );
                            int id = 0;
                            res = (char)(res & (char)klient->getNachrichtEncrypted( (char*)&id, 4 ));
                            CSKlient* c = cs->zSendeKlient( id );
                            if( c )
                            {
                                c->kick();
                                cs->absturzKlient( c->getKlientNummer() );
                            }
                            cs->removeAccount( id );
                        }
                        break;
                    case 2: // Account kommt online
                        if( 1 )
                        {
                            klient->sendeEncrypted( "\1", 1 );
                            int accId = 0;
                            int freundId = 0;
                            res = (char)(res & (char)klient->getNachrichtEncrypted( (char*)&accId, 4 ));
                            res = (char)(res & (char)klient->getNachrichtEncrypted( (char*)&freundId, 4 ));
                            CSKlient* klient = cs->zSendeKlient( freundId );
                            if( klient )
                                res = (char)(res & (char)klient->freundOnline( accId ));
                            else
                                res = 0;
                        }
                        break;
                    case 3: // Account geht offline
                        if( 1 )
                        {
                            klient->sendeEncrypted( "\1", 1 );
                            int accId = 0;
                            int freundId = 0;
                            res = (char)(res & (char)klient->getNachrichtEncrypted( (char*)&accId, 4 ));
                            res = (char)(res & (char)klient->getNachrichtEncrypted( (char*)&freundId, 4 ));
                            CSKlient* klient = cs->zSendeKlient( freundId );
                            if( klient )
                                res = (char)(res & (char)klient->freundOffline( accId ));
                            else
                                res = 0;
                        }
                        break;
                    case 4: // Chat nachricht
                        if( 1 )
                        {
                            klient->sendeEncrypted( "\1", 1 );
                            int vonAcc = 0;
                            int zuAcc = 0;
                            unsigned char len = 0;
                            char* nachricht = 0;
                            res = (char)(res & (char)klient->getNachrichtEncrypted( (char*)&vonAcc, 4 ));
                            res = (char)(res & (char)klient->getNachrichtEncrypted( (char*)&zuAcc, 4 ));
                            res = (char)(res & (char)klient->getNachrichtEncrypted( (char*)&len, 1 ));
                            if( len )
                            {
                                nachricht = new char[ len + 1 ];
                                nachricht[ (int)len ] = 0;
                                res = (char)(res & (char)klient->getNachrichtEncrypted( nachricht, len ));
                                CSKlient* klient = cs->zSendeKlient( zuAcc );
                                if( klient )
                                    res = (char)(res & (char)klient->nachricht( vonAcc, nachricht ));
                                else
                                    res = 0;
                            }
                            delete[]nachricht;
                        }
                        break;
                    case 5: // Gruppe einladung
                        if( 1 )
                        {
                            klient->sendeEncrypted( "\1", 1 );
                            int vonAcc = 0;
                            int zuAcc = 0;
                            int gruppeId = 0;
                            res = (char)(res & (char)klient->getNachrichtEncrypted( (char*)&zuAcc, 4 ));
                            res = (char)(res & (char)klient->getNachrichtEncrypted( (char*)&vonAcc, 4 ));
                            res = (char)(res & (char)klient->getNachrichtEncrypted( (char*)&gruppeId, 4 ));
                            CSKlient* klient = cs->zSendeKlient( zuAcc );
                            if( klient )
                                res = (char)(res & (char)klient->gruppeEinladung( vonAcc, gruppeId ));
                            else
                                res = 0;
                        }
                        break;
                    case 6: // Account Status ändert sich
                        if( 1 )
                        {
                            klient->sendeEncrypted( "\1", 1 );
                            int accId = 0;
                            int freundId = 0;
                            unsigned char len = 0;
                            char* status = 0;
                            res = (char)(res & (char)klient->getNachrichtEncrypted( (char*)&accId, 4 ));
                            res = (char)(res & (char)klient->getNachrichtEncrypted( (char*)&freundId, 4 ));
                            res = (char)(res & (char)klient->getNachrichtEncrypted( (char*)&len, 1 ));
                            if( len )
                            {
                                status = new char[ len + 1 ];
                                status[ (int)len ] = 0;
                                res = (char)(res & (char)klient->getNachrichtEncrypted( status, len ));
                                CSKlient* klient = cs->zSendeKlient( freundId );
                                if( klient )
                                    res = (char)(res & (char)klient->accountStatusChange( accId, status ));
                                else
                                    res = 0;
                            }
                            delete[]status;
                        }
                        break;
                    case 7: // Account Name ändert sich
                        if( 1 )
                        {
                            klient->sendeEncrypted( "\1", 1 );
                            int accId = 0;
                            int freundId = 0;
                            unsigned char len = 0;
                            char* name = 0;
                            res = (char)(res & (char)klient->getNachrichtEncrypted( (char*)&accId, 4 ));
                            res = (char)(res & (char)klient->getNachrichtEncrypted( (char*)&freundId, 4 ));
                            res = (char)(res & (char)klient->getNachrichtEncrypted( (char*)&len, 1 ));
                            if( len )
                            {
                                name = new char[ len + 1 ];
                                name[ (int)len ] = 0;
                                res = (char)(res & (char)klient->getNachrichtEncrypted( name, len ));
                                CSKlient* klient = cs->zSendeKlient( freundId );
                                if( klient )
                                    res = (char)(res & (char)klient->accountNameChange( accId, name ));
                                else
                                    res = 0;
                            }
                            delete[]name;
                        }
                        break;
                    case 8: // Kein Freund mehr
                        if( 1 )
                        {
                            klient->sendeEncrypted( "\1", 1 );
                            int accId = 0;
                            int freundId = 0;
                            res = (char)(res & (char)klient->getNachrichtEncrypted( (char*)&accId, 4 ));
                            res = (char)(res & (char)klient->getNachrichtEncrypted( (char*)&freundId, 4 ));
                            CSKlient* klient = cs->zSendeKlient( freundId );
                            if( klient )
                                res = (char)(res & (char)klient->keinFreundMehr( accId ));
                            else
                                res = 0;
                        }
                        break;
                    case 9: // Freundesanfrage
                        if( 1 )
                        {
                            klient->sendeEncrypted( "\1", 1 );
                            int accId = 0;
                            int freundId = 0;
                            res = (char)(res & (char)klient->getNachrichtEncrypted( (char*)&accId, 4 ));
                            res = (char)(res & (char)klient->getNachrichtEncrypted( (char*)&freundId, 4 ));
                            CSKlient* klient = cs->zSendeKlient( freundId );
                            if( klient )
                                res = (char)(res & (char)klient->freundesAnfrage( accId ));
                            else
                                res = 0;
                        }
                        break;
                    case 0xA: // Neuer Freund
                        if( 1 )
                        {
                            klient->sendeEncrypted( "\1", 1 );
                            int accId = 0;
                            int freundId = 0;
                            res = (char)(res & (char)klient->getNachrichtEncrypted( (char*)&accId, 4 ));
                            res = (char)(res & (char)klient->getNachrichtEncrypted( (char*)&freundId, 4 ));
                            CSKlient* klient = cs->zSendeKlient( freundId );
                            if( klient )
                                res = (char)(res & (char)klient->neuerFreund( accountId ));
                            else
                                res = 0;
                        }
                        break;
                    case 0xB: // Einladung zum Chatroom
                        if( 1 )
                        {
                            klient->sendeEncrypted( "\1", 1 );
                            int vonAcc = 0;
                            int zuAcc = 0;
                            int chatroomId = 0;
                            res = (char)(res & (char)klient->getNachrichtEncrypted( (char*)&vonAcc, 4 ));
                            res = (char)(res & (char)klient->getNachrichtEncrypted( (char*)&zuAcc, 4 ));
                            res = (char)(res & (char)klient->getNachrichtEncrypted( (char*)&chatroomId, 4 ));
                            CSKlient* klient = cs->zSendeKlient( zuAcc );
                            if( klient )
                                res = (char)(res & (char)klient->einladungZumChatroom( vonAcc, chatroomId ));
                            else
                                res = 0;
                        }
                        break;
                    case 0xC: // Spieler betritt Chatroom
                        if( 1 )
                        {
                            klient->sendeEncrypted( "\1", 1 );
                            int accId = 0;
                            int zuAcc = 0;
                            int chatroomId = 0;
                            res = (char)(res & (char)klient->getNachrichtEncrypted( (char*)&accId, 4 ));
                            res = (char)(res & (char)klient->getNachrichtEncrypted( (char*)&zuAcc, 4 ));
                            res = (char)(res & (char)klient->getNachrichtEncrypted( (char*)&chatroomId, 4 ));
                            CSKlient* klient = cs->zSendeKlient( zuAcc );
                            if( klient )
                                res = (char)(res & (char)klient->spielerBetrittChatroom( chatroomId, accId ));
                            else
                                res = 0;
                        }
                        break;
                    case 0xD: // Chatroom nachricht
                        if( 1 )
                        {
                            klient->sendeEncrypted( "\1", 1 );
                            int vonAcc = 0;
                            int zuAcc = 0;
                            int chatroomId = 0;
                            unsigned char len = 0;
                            char* nachricht = 0;
                            res = (char)(res & (char)klient->getNachrichtEncrypted( (char*)&vonAcc, 4 ));
                            res = (char)(res & (char)klient->getNachrichtEncrypted( (char*)&zuAcc, 4 ));
                            res = (char)(res & (char)klient->getNachrichtEncrypted( (char*)&chatroomId, 4 ));
                            res = (char)(res & (char)klient->getNachrichtEncrypted( (char*)&len, 1 ));
                            if( len )
                            {
                                nachricht = new char[ len + 1 ];
                                nachricht[ (int)len ] = 0;
                                res = (char)(res & (char)klient->getNachrichtEncrypted( nachricht, len ));
                                CSKlient* klient = cs->zSendeKlient( zuAcc );
                                if( klient )
                                    res = (char)(res & (char)klient->chatroomNachricht( chatroomId, vonAcc, nachricht ));
                                else
                                    res = 0;
                            }
                            delete[]nachricht;
                        }
                        break;
                    case 0xE: // Spieler verlässt Chatroom
                        if( 1 )
                        {
                            klient->sendeEncrypted( "\1", 1 );
                            int accId = 0;
                            int zuAcc = 0;
                            int chatroomId = 0;
                            res = (char)(res & (char)klient->getNachrichtEncrypted( (char*)&accId, 4 ));
                            res = (char)(res & (char)klient->getNachrichtEncrypted( (char*)&zuAcc, 4 ));
                            res = (char)(res & (char)klient->getNachrichtEncrypted( (char*)&chatroomId, 4 ));
                            CSKlient* klient = cs->zSendeKlient( zuAcc );
                            if( klient )
                                res = (char)(res & (char)klient->spielerLeavesChatroom( chatroomId, accId ));
                            else
                                res = 0;
                        }
                        break;
                    case 0xF: // Freund Einladung abgelehnt
                        if( 1 )
                        {
                            klient->sendeEncrypted( "\1", 1 );
                            int accId = 0;
                            int freundId = 0;
                            res = (char)(res & (char)klient->getNachrichtEncrypted( (char*)&accId, 4 ));
                            res = (char)(res & (char)klient->getNachrichtEncrypted( (char*)&freundId, 4 ));
                            CSKlient* klient = cs->zSendeKlient( freundId );
                            if( klient )
                                res = (char)(res & (char)klient->freundesAnfrageAbgelehnt( accId ));
                            else
                                res = 0;
                        }
                        break;
                    case 0x10: // Chatroom Einladungabgelehnt
                        if( 1 )
                        {
                            klient->sendeEncrypted( "\1", 1 );
                            int accId = 0;
                            int zuAcc = 0;
                            int chatroomId = 0;
                            res = (char)(res & (char)klient->getNachrichtEncrypted( (char*)&accId, 4 ));
                            res = (char)(res & (char)klient->getNachrichtEncrypted( (char*)&zuAcc, 4 ));
                            res = (char)(res & (char)klient->getNachrichtEncrypted( (char*)&chatroomId, 4 ));
                            CSKlient* klient = cs->zSendeKlient( zuAcc );
                            if( klient )
                                res = (char)(res & (char)klient->einladungZumChatroomAbgelehnt( accId, chatroomId ));
                            else
                                res = 0;
                        }
                        break;
                    case 0x11: // Fehler
                        if( 1 )
                        {
                            klient->sendeEncrypted( "\1", 1 );
                            int zuAcc = 0;
                            unsigned char len = 0;
                            char* nachricht = 0;
                            res = (char)(res & (char)klient->getNachrichtEncrypted( (char*)&zuAcc, 4 ));
                            res = (char)(res & (char)klient->getNachrichtEncrypted( (char*)&len, 1 ));
                            if( len )
                            {
                                nachricht = new char[ len + 1 ];
                                nachricht[ (int)len ] = 0;
                                res = (char)(res & (char)klient->getNachrichtEncrypted( nachricht, len ));
                                CSKlient* klient = cs->zSendeKlient( zuAcc );
                                if( klient )
                                    res = (char)(res & (char)klient->errorZuKlient( nachricht ));
                                else
                                    res = 0;
                            }
                            delete[]nachricht;
                        }
                        break;
                    case 0x12: // Chatroom Admin
                        if( 1 )
                        {
                            klient->sendeEncrypted( "\1", 1 );
                            int zuAcc = 0;
                            int chatroomId = 0;
                            res = (char)(res & (char)klient->getNachrichtEncrypted( (char*)&zuAcc, 4 ));
                            res = (char)(res & (char)klient->getNachrichtEncrypted( (char*)&chatroomId, 4 ));
                            CSKlient* klient = cs->zSendeKlient( zuAcc );
                            if( klient )
                                res = (char)(res & (char)klient->chatroomAdmin( chatroomId ));
                            else
                                res = 0;
                        }
                        break;
                    case 0x13: // Chatroom Kick
                        if( 1 )
                        {
                            klient->sendeEncrypted( "\1", 1 );
                            int zuAcc = 0;
                            int chatroomId = 0;
                            res = (char)(res & (char)klient->getNachrichtEncrypted( (char*)&zuAcc, 4 ));
                            res = (char)(res & (char)klient->getNachrichtEncrypted( (char*)&chatroomId, 4 ));
                            CSKlient* klient = cs->zSendeKlient( zuAcc );
                            if( klient )
                                res = (char)(res & (char)klient->chatroomKick( chatroomId ));
                            else
                                res = 0;
                        }
                        break;
                    case 0x14: // spieler betritt gruppe
                        if( 1 )
                        {
                            klient->sendeEncrypted( "\1", 1 );
                            int zuAcc = 0;
                            int accountId = 0;
                            int gruppeId = 0;
                            res = (char)(res & (char)klient->getNachrichtEncrypted( (char*)&zuAcc, 4 ));
                            res = (char)(res & (char)klient->getNachrichtEncrypted( (char*)&accountId, 4 ));
                            res = (char)(res & (char)klient->getNachrichtEncrypted( (char*)&gruppeId, 4 ));
                            CSKlient* klient = cs->zSendeKlient( zuAcc );
                            if( klient )
                                res = (char)(res & (char)klient->spielerBertittGruppe( accountId, gruppeId ));
                            else
                                res = 0;
                        }
                        break;
                    case 0x15: // spieler verlässt gruppe
                        if( 1 )
                        {
                            klient->sendeEncrypted( "\1", 1 );
                            int zuAcc = 0;
                            int accountId = 0;
                            int gruppeId = 0;
                            res = (char)(res & (char)klient->getNachrichtEncrypted( (char*)&zuAcc, 4 ));
                            res = (char)(res & (char)klient->getNachrichtEncrypted( (char*)&accountId, 4 ));
                            res = (char)(res & (char)klient->getNachrichtEncrypted( (char*)&gruppeId, 4 ));
                            CSKlient* klient = cs->zSendeKlient( zuAcc );
                            if( klient )
                                res = (char)(res & (char)klient->spielerLeavesGruppe( accountId, gruppeId ));
                            else
                                res = 0;
                        }
                        break;
                    case 0x16: // kick spieler aus gruppe
                        if( 1 )
                        {
                            klient->sendeEncrypted( "\1", 1 );
                            int zuAcc = 0;
                            int gruppeId = 0;
                            res = (char)(res & (char)klient->getNachrichtEncrypted( (char*)&zuAcc, 4 ));
                            res = (char)(res & (char)klient->getNachrichtEncrypted( (char*)&gruppeId, 4 ));
                            CSKlient* klient = cs->zSendeKlient( zuAcc );
                            if( klient )
                                res = (char)(res & (char)klient->kickAusGruppe( gruppeId ));
                            else
                                res = 0;
                        }
                        break;
                    case 0x17: // gruppe angemeldet
                        if( 1 )
                        {
                            klient->sendeEncrypted( "\1", 1 );
                            int zuAcc = 0;
                            int gruppeId = 0;
                            res = (char)(res & (char)klient->getNachrichtEncrypted( (char*)&zuAcc, 4 ));
                            res = (char)(res & (char)klient->getNachrichtEncrypted( (char*)&gruppeId, 4 ));
                            CSKlient* klient = cs->zSendeKlient( zuAcc );
                            if( klient )
                                res = (char)(res & (char)klient->gruppeAnmelden( gruppeId ));
                            else
                                res = 0;
                        }
                        break;
                    case 0x18: // gruppe abgemeldet
                        if( 1 )
                        {
                            klient->sendeEncrypted( "\1", 1 );
                            int zuAcc = 0;
                            int gruppeId = 0;
                            res = (char)(res & (char)klient->getNachrichtEncrypted( (char*)&zuAcc, 4 ));
                            res = (char)(res & (char)klient->getNachrichtEncrypted( (char*)&gruppeId, 4 ));
                            CSKlient* klient = cs->zSendeKlient( zuAcc );
                            if( klient )
                                res = (char)(res & (char)klient->gruppeAbmelden( gruppeId ));
                            else
                                res = 0;
                        }
                        break;
                    case 0x19: // gruppe nachricht
                        if( 1 )
                        {
                            klient->sendeEncrypted( "\1", 1 );
                            int zuAcc = 0;
                            int gruppeId = 0;
                            unsigned char len;
                            res = (char)(res & (char)klient->getNachrichtEncrypted( (char*)&zuAcc, 4 ));
                            res = (char)(res & (char)klient->getNachrichtEncrypted( (char*)&gruppeId, 4 ));
                            res = (char)(res & (char)klient->getNachrichtEncrypted( (char*)&len, 1 ));
                            char* nachricht = new char[ len + 1 ];
                            nachricht[ (int)len ] = 0;
                            if( len )
                                res = (char)(res & (char)klient->getNachrichtEncrypted( nachricht, len ));
                            CSKlient* klient = cs->zSendeKlient( zuAcc );
                            if( klient )
                                res = (char)(res & (char)klient->gruppeNachricht( gruppeId, nachricht ));
                            else
                                res = 0;
                            delete[]nachricht;
                        }
                        break;
                    case 0x1A: // gruppe spiel starten
                        if( 1 )
                        {
                            klient->sendeEncrypted( "\1", 1 );
                            int zuAcc = 0;
                            int gruppeId = 0;
                            char starten;
                            res = (char)(res & (char)klient->getNachrichtEncrypted( (char*)&zuAcc, 4 ));
                            res = (char)(res & (char)klient->getNachrichtEncrypted( (char*)&gruppeId, 4 ));
                            res = (char)(res & (char)klient->getNachrichtEncrypted( &starten, 1 ));
                            CSKlient* klient = cs->zSendeKlient( zuAcc );
                            if( klient )
                                res = (char)(res & (char)klient->gruppeSpielStarten( gruppeId, starten == 1 ));
                            else
                                res = 0;
                        }
                        break;
                    case 0x1B: // gruppe admin
                        if( 1 )
                        {
                            klient->sendeEncrypted( "\1", 1 );
                            int zuAcc = 0;
                            int adminId = 0;
                            int gruppeId = 0;
                            res = (char)(res & (char)klient->getNachrichtEncrypted( (char*)&zuAcc, 4 ));
                            res = (char)(res & (char)klient->getNachrichtEncrypted( (char*)&adminId, 4 ));
                            res = (char)(res & (char)klient->getNachrichtEncrypted( (char*)&gruppeId, 4 ));
                            CSKlient* klient = cs->zSendeKlient( zuAcc );
                            if( klient )
                                res = (char)(res & (char)klient->setGruppeAdmin( gruppeId, adminId ));
                            else
                                res = 0;
                        }
                        break;
                    case 0x1C: // gruppe Einladung abgelehnt
                        if( 1 )
                        {
                            klient->sendeEncrypted( "\1", 1 );
                            int zuAcc = 0;
                            int accountId = 0;
                            int gruppeId = 0;
                            res = (char)(res & (char)klient->getNachrichtEncrypted( (char*)&zuAcc, 4 ));
                            res = (char)(res & (char)klient->getNachrichtEncrypted( (char*)&accountId, 4 ));
                            res = (char)(res & (char)klient->getNachrichtEncrypted( (char*)&gruppeId, 4 ));
                            CSKlient* klient = cs->zSendeKlient( zuAcc );
                            if( klient )
                                res = (char)(res & (char)klient->gruppeEinladungAbgelehnt( gruppeId, accountId ));
                            else
                                res = 0;
                        }
                        break;
                    case 0x1D: // Spiel Server verbindungs aufforderung
                        if( 1 )
                        {
                            klient->sendeEncrypted( "\1", 1 );
                            int zuAcc = 0;
                            unsigned short port;
                            unsigned char* ip = new unsigned char[ 4 ];
                            res = (char)(res & (char)klient->getNachrichtEncrypted( (char*)&zuAcc, 4 ));
                            res = (char)(res & (char)klient->getNachrichtEncrypted( (char*)&port, 2 ));
                            res = (char)(res & (char)klient->getNachrichtEncrypted( (char*)ip, 4 ));
                            CSKlient* klient = cs->zSendeKlient( zuAcc );
                            if( klient )
                                res = (char)(res & (char)klient->spielServerVerbindungsAnfrage( port, ip ));
                            else
                                res = 0;
                            delete[] ip;
                        }
                        break;
                    case 0x1E: // gruppe einladung Abbrechen
                        if( 1 )
                        {
                            klient->sendeEncrypted( "\1", 1 );
                            int zuAcc = 0;
                            int gruppeId = 0;
                            int accountId = 0;
                            res = (char)(res & (char)klient->getNachrichtEncrypted( (char*)&zuAcc, 4 ));
                            res = (char)(res & (char)klient->getNachrichtEncrypted( (char*)&gruppeId, 4 ));
                            res = (char)(res & (char)klient->getNachrichtEncrypted( (char*)&accountId, 4 ));
                            CSKlient* klient = cs->zSendeKlient( zuAcc );
                            if( klient )
                                res = (char)(res & (char)klient->gruppeEinladungAbgebrochen( gruppeId, accountId ));
                            else
                                res = 0;
                        }
                        break;
                    case 0x1F: // gruppe einladung Neu
                        if( 1 )
                        {
                            klient->sendeEncrypted( "\1", 1 );
                            int zuAcc = 0;
                            int gruppeId = 0;
                            int accountId = 0;
                            res = (char)(res & (char)klient->getNachrichtEncrypted( (char*)&zuAcc, 4 ));
                            res = (char)(res & (char)klient->getNachrichtEncrypted( (char*)&gruppeId, 4 ));
                            res = (char)(res & (char)klient->getNachrichtEncrypted( (char*)&accountId, 4 ));
                            CSKlient* klient = cs->zSendeKlient( zuAcc );
                            if( klient )
                                res = (char)(res & (char)klient->gruppeEinladungNeu( gruppeId, accountId ));
                            else
                                res = 0;
                        }
                        break;
                    default:
                        res = 0;
                        break;
                    }
                    klient->sendeEncrypted( &res, 1 );
                }
                break;
            case 6: // Chat Nachricht
                if( 1 )
                {
                    if( !accountId || !klientNummer )
                    {
                        klient->sendeEncrypted( "\0", 1 );
                        CSKlient* c = cs->zSendeKlient( accountId );
                        if( c )
                            c->errorZuKlient( "Du bist nicht identifiziert." );
                        break;
                    }
                    klient->sendeEncrypted( "\1", 1 );
                    int zuAccount = 0;
                    unsigned char len = 0;
                    char* nachricht = 0;
                    klient->getNachrichtEncrypted( (char*)&zuAccount, 4 );
                    klient->getNachrichtEncrypted( (char*)&len, 1 );
                    if( len )
                    {
                        nachricht = new char[ len + 1 ];
                        nachricht[ (int)len ] = 0;
                        klient->getNachrichtEncrypted( nachricht, len );
                        MSGWeiterleitung* weiter = new MSGWeiterleitung( dynamic_cast<ChatServer*>(cs->getThis()) );
                        if( !weiter->chatNachricht( accountId, zuAccount, nachricht ) )
                        {
                            cs->zDB()->speicherChatNachricht( accountId, zuAccount, nachricht );
                            CSKlient* c = cs->zSendeKlient( accountId );
                            if( c )
                                c->errorZuKlient( "Der Account ist momentan nicht erreichbar." );
                        }
                        delete weiter;
                        delete[]nachricht;
                    }
                }
                break;
            case 8: // Account Name ändern
                if( 1 )
                {
                    if( !accountId || !klientNummer )
                    {
                        klient->sendeEncrypted( "\0", 1 );
                        CSKlient* c = cs->zSendeKlient( accountId );
                        if( c )
                            c->errorZuKlient( "Du bist nicht identifiziert." );
                        break;
                    }
                    klient->sendeEncrypted( "\1", 1 );
                    unsigned char len;
                    char* name;
                    klient->getNachrichtEncrypted( (char*)&len, 1 );
                    if( len )
                    {
                        name = new char[ len + 1 ];
                        name[ (int)len ] = 0;
                        klient->getNachrichtEncrypted( name, len );
                        if( cs->zDB()->accountNameChange( accountId, name ) )
                        {
                            klient->sendeEncrypted( "\1", 1 );
                            MSGWeiterleitung* weiter = new MSGWeiterleitung( dynamic_cast<ChatServer*>(cs->getThis()) );
                            weiter->accountNameChange( accountId, name );
                            delete weiter;
                        }
                        else
                        {
                            klient->sendeEncrypted( "\0", 1 );
                            CSKlient* c = cs->zSendeKlient( accountId );
                            if( c )
                                c->errorZuKlient( "Beim ändern des Namens ist ein Fehler aufgetreten." );
                        }
                        delete[]name;
                    }
                }
                break;
            case 9: // Freundschaft beenden
                if( 1 )
                {
                    if( !accountId || !klientNummer )
                    {
                        klient->sendeEncrypted( "\0", 1 );
                        CSKlient* c = cs->zSendeKlient( accountId );
                        if( c )
                            c->errorZuKlient( "Du bist nicht identifiziert." );
                        break;
                    }
                    klient->sendeEncrypted( "\1", 1 );
                    int freundId = 0;
                    klient->getNachrichtEncrypted( (char*)&freundId, 4 );
                    if( cs->zDB()->beendeFreundschaft( accountId, freundId ) )
                    {
                        klient->sendeEncrypted( "\1", 1 );
                        MSGWeiterleitung* weiter = new MSGWeiterleitung( dynamic_cast<ChatServer*>(cs->getThis()) );
                        weiter->accountKeinFreundMehr( accountId, freundId );
                        weiter->accountKeinFreundMehr( freundId, accountId );
                        delete weiter;
                    }
                    else
                    {
                        klient->sendeEncrypted( "\0", 1 );
                        CSKlient* c = cs->zSendeKlient( accountId );
                        if( c )
                            c->errorZuKlient( "Die Freundschaft konnte nicht beendet werden." );
                    }
                }
                break;
            case 0xA: // Freundschaftsanfrage senden
                if( 1 )
                {
                    if( !accountId || !klientNummer )
                    {
                        klient->sendeEncrypted( "\0", 1 );
                        CSKlient* c = cs->zSendeKlient( accountId );
                        if( c )
                            c->errorZuKlient( "Du bist nicht identifiziert." );
                        break;
                    }
                    klient->sendeEncrypted( "\1", 1 );
                    int freundId = 0;
                    klient->getNachrichtEncrypted( (char*)&freundId, 4 );
                    if( cs->zDB()->proveFreundschaftsAnfrage( accountId, freundId ) )
                    {
                        MSGWeiterleitung* weiter = new MSGWeiterleitung( dynamic_cast<ChatServer*>(cs->getThis()) );
                        if( !weiter->freundesAnfrage( accountId, freundId ) )
                            cs->zDB()->saveFreundschaftsAnfrage( accountId, freundId );
                        klient->sendeEncrypted( "\1", 1 );
                        delete weiter;
                    }
                    else
                    {
                        klient->sendeEncrypted( "\0", 1 );
                        CSKlient* c = cs->zSendeKlient( accountId );
                        if( c )
                            c->errorZuKlient( "Diesem Account konnte keine Freundschaftsanfrage gesendet werden." );
                    }
                }
                break;
            case 0xB: // Freundschaftsanfrage beantworten
                if( 1 )
                {
                    if( !accountId || !klientNummer )
                    {
                        klient->sendeEncrypted( "\0", 1 );
                        CSKlient* c = cs->zSendeKlient( accountId );
                        if( c )
                            c->errorZuKlient( "Du bist nicht identifiziert." );
                        break;
                    }
                    klient->sendeEncrypted( "\1", 1 );
                    int zuAccount = 0;
                    char ok = 0;
                    klient->getNachrichtEncrypted( (char*)&zuAccount, 4 );
                    klient->getNachrichtEncrypted( &ok, 1 );
                    MSGWeiterleitung* weiter = new MSGWeiterleitung( dynamic_cast<ChatServer*>(cs->getThis()) );
                    if( !ok )
                    {
                        weiter->freundEinladungAbgelehnt( accountId, zuAccount );
                        klient->sendeEncrypted( "\1", 1 );
                    }
                    else
                    {
                        if( cs->zDB()->neueFreundschaft( accountId, zuAccount ) )
                        {
                            weiter->neuerFreund( accountId, zuAccount );
                            weiter->neuerFreund( zuAccount, accountId );
                            if( cs->zDB()->accountIstOnline( zuAccount ) )
                            {
                                weiter->accountOnline( zuAccount );
                                weiter->accountOnline( accountId );
                            }
                            klient->sendeEncrypted( "\1", 1 );
                        }
                        else
                        {
                            klient->sendeEncrypted( "\0", 1 );
                            CSKlient* c = cs->zSendeKlient( accountId );
                            if( c )
                                c->errorZuKlient( "Fehler beim erstellen der neuen Freundschaft." );
                            weiter->fehler( zuAccount, "Fehler beim erstellen der neuen Freundschaft." );
                        }
                    }
                    delete weiter;
                }
                break;
            case 0xC: // Chatroom erstellen
                if( 1 )
                {
                    if( !accountId || !klientNummer )
                    {
                        klient->sendeEncrypted( "\0", 1 );
                        CSKlient* c = cs->zSendeKlient( accountId );
                        if( c )
                            c->errorZuKlient( "Du bist nicht identifiziert." );
                        break;
                    }
                    klient->sendeEncrypted( "\1", 1 );
                    unsigned char nLen = 0;
                    char* name = 0;
                    klient->getNachrichtEncrypted( (char*)&nLen, 1 );
                    if( nLen )
                    {
                        name = new char[ nLen + 1 ];
                        name[ (int)nLen ] = 0;
                        klient->getNachrichtEncrypted( name, nLen );
                    }
                    if( !name )
                    {
                        klient->sendeEncrypted( "\0", 1 );
                        CSKlient* c = cs->zSendeKlient( accountId );
                        if( c )
                            c->errorZuKlient( "Du musst einen Namen eingeben." );
                    }
                    else
                    {
                        klient->sendeEncrypted( "\1", 1 );
                        int id = cs->zDB()->chatroomErstellen( accountId, name );
                        klient->sendeEncrypted( (char*)&id, 4 );
                        if( !id )
                        {
                            CSKlient* c = cs->zSendeKlient( accountId );
                            if( c )
                                c->errorZuKlient( "Das Chatroom konnte nicht erstellt werden." );
                        }
                        else
                        {
                            CSKlient* c = cs->zSendeKlient( accountId );
                            if( c )
                            {
                                c->spielerBetrittChatroom( id, accountId );
                                c->chatroomAdmin( id );
                            }
                        }
                    }
                    delete[]name;
                }
                break;
            case 0xD: // Zum Chatroom einladen
                if( 1 )
                {
                    if( !accountId || !klientNummer )
                    {
                        klient->sendeEncrypted( "\0", 1 );
                        CSKlient* c = cs->zSendeKlient( accountId );
                        if( c )
                            c->errorZuKlient( "Du bist nicht identifiziert." );
                        break;
                    }
                    klient->sendeEncrypted( "\1", 1 );
                    int zuAccountId = 0;
                    int chatroomId = 0;
                    klient->getNachrichtEncrypted( (char*)&zuAccountId, 4 );
                    klient->getNachrichtEncrypted( (char*)&chatroomId, 4 );
                    if( cs->zDB()->proveChatroomEinladung( accountId, zuAccountId, chatroomId ) )
                    {
                        MSGWeiterleitung* weiter = new MSGWeiterleitung( dynamic_cast<ChatServer*>(cs->getThis()) );
                        if( weiter->einladungZumChatroom( accountId, zuAccountId, chatroomId ) )
                            klient->sendeEncrypted( "\1", 1 );
                        else
                        {
                            klient->sendeEncrypted( "\0", 1 );
                            if( weiter->getLetzterFehler() )
                            {
                                CSKlient* c = cs->zSendeKlient( accountId );
                                if( c )
                                    c->errorZuKlient( weiter->getLetzterFehler() );
                            }
                        }
                        delete weiter;
                    }
                    else
                    {
                        klient->sendeEncrypted( "\0", 1 );
                        CSKlient* c = cs->zSendeKlient( accountId );
                        if( c )
                            c->errorZuKlient( "Der Account konnte nicht eingeladen werden." );
                    }
                }
                break;
            case 0xE: // Chatroom einladung ablehnen
                if( 1 )
                {
                    if( !accountId || !klientNummer )
                    {
                        klient->sendeEncrypted( "\0", 1 );
                        CSKlient* c = cs->zSendeKlient( accountId );
                        if( c )
                            c->errorZuKlient( "Du bist nicht identifiziert." );
                        break;
                    }
                    klient->sendeEncrypted( "\1", 1 );
                    int zuAccountId = 0;
                    int chatroomId = 0;
                    klient->getNachrichtEncrypted( (char*)&zuAccountId, 4 );
                    klient->getNachrichtEncrypted( (char*)&chatroomId, 4 );
                    MSGWeiterleitung* weiter = new MSGWeiterleitung( dynamic_cast<ChatServer*>(cs->getThis()) );
                    weiter->chatroomEinladungAbgelehnt( accountId, chatroomId, zuAccountId );
                    delete weiter;
                    klient->sendeEncrypted( "\1", 1 );
                }
                break;
            case 0xF: // Chatroom betreten
                if( 1 )
                {
                    if( !accountId || !klientNummer )
                    {
                        klient->sendeEncrypted( "\0", 1 );
                        CSKlient* c = cs->zSendeKlient( accountId );
                        if( c )
                            c->errorZuKlient( "Du bist nicht identifiziert." );
                        break;
                    }
                    klient->sendeEncrypted( "\1", 1 );
                    int chatroomId = 0;
                    klient->getNachrichtEncrypted( (char*)&chatroomId, 4 );
                    if( cs->zDB()->chatroomBeitreten( accountId, chatroomId ) )
                    {
                        MSGWeiterleitung* weiter = new MSGWeiterleitung( dynamic_cast<ChatServer*>(cs->getThis()) );
                        weiter->spielerBetrittChatroom( accountId, chatroomId );
                        delete weiter;
                        klient->sendeEncrypted( "\1", 1 );
                        Array< int >* accounts = new Array< int >();
                        int anzahl = cs->zDB()->getChatroomAccount( chatroomId, accounts );
                        CSKlient* c = cs->zSendeKlient( accountId );
                        if( c )
                        {
                            if( !c->spielerImChatroom( chatroomId, (char)anzahl, accounts ) )
                                c->errorZuKlient( "Fehler beim senden der momentanen Spieler im Chatroom." );
                        }
                        accounts->release();
                    }
                    else
                        klient->sendeEncrypted( "\0", 1 );
                }
                break;
            case 0x10: // Chatroom Nachricht
                if( 1 )
                {
                    if( !accountId || !klientNummer )
                    {
                        klient->sendeEncrypted( "\0", 1 );
                        CSKlient* c = cs->zSendeKlient( accountId );
                        if( c )
                            c->errorZuKlient( "Du bist nicht identifiziert." );
                        break;
                    }
                    klient->sendeEncrypted( "\1", 1 );
                    int chatroomId = 0;
                    unsigned char len = 0;
                    char* nachricht = 0;
                    klient->getNachrichtEncrypted( (char*)&chatroomId, 4 );
                    klient->getNachrichtEncrypted( (char*)&len, 1 );
                    if( len )
                    {
                        nachricht = new char[ len + 1 ];
                        nachricht[ (int)len ] = 0;
                        klient->getNachrichtEncrypted( nachricht, len );
                        Text* message = cs->zDB()->getAccountRufName( accountId );
                        message->append( ": " );
                        message->append( nachricht );
                        MSGWeiterleitung* weiter = new MSGWeiterleitung( dynamic_cast<ChatServer*>(cs->getThis()) );
                        if( weiter->chatroomNachricht( accountId, message->getText(), chatroomId ) )
                            klient->sendeEncrypted( "\1", 1 );
                        else
                        {
                            klient->sendeEncrypted( "\0", 1 );
                            if( weiter->getLetzterFehler() )
                            {
                                CSKlient* c = cs->zSendeKlient( accountId );
                                if( c )
                                    c->errorZuKlient( weiter->getLetzterFehler() );
                            }
                        }
                        message->release();
                        delete weiter;
                        delete[]nachricht;
                    }
                    else
                        klient->sendeEncrypted( "\0", 1 );
                }
                break;
            case 0x11: // Chatroom verlassen
                if( 1 )
                {
                    if( !accountId || !klientNummer )
                    {
                        klient->sendeEncrypted( "\0", 1 );
                        CSKlient* c = cs->zSendeKlient( accountId );
                        if( c )
                            c->errorZuKlient( "Du bist nicht identifiziert." );
                        break;
                    }
                    klient->sendeEncrypted( "\1", 1 );
                    int chatroomId = 0;
                    klient->getNachrichtEncrypted( (char*)&chatroomId, 4 );
                    int aktion = cs->zDB()->chatroomVerlassen( accountId, chatroomId );
                    if( !aktion )
                        klient->sendeEncrypted( "\0", 1 );
                    else
                    {
                        if( aktion == 3 )
                        {
                            MSGWeiterleitung* weiter = new MSGWeiterleitung( dynamic_cast<ChatServer*>(cs->getThis()) );
                            weiter->chatroomAdmin( chatroomId, cs->zDB()->getChatroomAdmin( chatroomId ) );
                            delete weiter;
                        }
                        if( aktion != 2 )
                        {
                            MSGWeiterleitung* weiter = new MSGWeiterleitung( dynamic_cast<ChatServer*>(cs->getThis()) );
                            weiter->spielerLeavestChatroom( accountId, chatroomId );
                            delete weiter;
                        }
                        klient->sendeEncrypted( "\1", 1 );
                    }
                }
                break;
            case 0x12: // Chatroom Kick
                if( 1 )
                {
                    if( !accountId || !klientNummer )
                    {
                        klient->sendeEncrypted( "\0", 1 );
                        CSKlient* c = cs->zSendeKlient( accountId );
                        if( c )
                            c->errorZuKlient( "Du bist nicht identifiziert." );
                        break;
                    }
                    klient->sendeEncrypted( "\1", 1 );
                    int chatroomId = 0;
                    int accountId = 0;
                    klient->getNachrichtEncrypted( (char*)&chatroomId, 4 );
                    klient->getNachrichtEncrypted( (char*)&accountId, 4 );
                    if( accountId == (int)this->accountId )
                    {
                        klient->sendeEncrypted( "\0", 1 );
                        CSKlient* c = cs->zSendeKlient( accountId );
                        if( c )
                            c->errorZuKlient( "Du kannst dich selbst nicht kicken." );
                        break;
                    }
                    if( cs->zDB()->getChatroomAdmin( chatroomId ) == (int)this->accountId )
                    {
                        if( cs->zDB()->chatroomVerlassen( accountId, chatroomId ) )
                        {
                            MSGWeiterleitung* weiter = new MSGWeiterleitung( dynamic_cast<ChatServer*>(cs->getThis()) );
                            weiter->chatroomKick( chatroomId, accountId );
                            weiter->spielerLeavestChatroom( accountId, chatroomId );
                            delete weiter;
                            klient->sendeEncrypted( "\1", 1 );
                        }
                        else
                        {
                            klient->sendeEncrypted( "\0", 1 );
                            CSKlient* c = cs->zSendeKlient( accountId );
                            if( c )
                                c->errorZuKlient( "Der Spieler konnte nicht entfernt werden." );
                        }
                    }
                    else
                    {
                        klient->sendeEncrypted( "\0", 1 );
                        CSKlient* c = cs->zSendeKlient( accountId );
                        if( c )
                            c->errorZuKlient( "Du bist nicht der Administrator dieses Chatrooms." );
                    }
                }
                break;
            case 0x13: // Anfrage nach Freundes Liste
                if( 1 )
                {
                    klient->sendeEncrypted( "\1", 1 );
                    Array< int >* freundId = new Array< int >();
                    int anz = cs->zDB()->getAccountFreunde( accountId, freundId );
                    CSKlient* c = cs->zSendeKlient( accountId );
                    if( c )
                        c->freunde( (char)anz, freundId );
                    freundId->release();
                    freundId = new Array< int >();
                    anz = cs->zDB()->getAccountOnlineFreunde( accountId, freundId );
                    for( int i = 0; i < anz; i++ )
                    {
                        if( c )
                            c->freundOnline( freundId->get( i ) );
                    }
                    freundId->release();
                }
                break;
            case 0x14: // Anfrage nach chat nachrichten in abwesenheit
                if( 1 )
                {
                    klient->sendeEncrypted( "\1", 1 );
                    Array< int >* vonAccount = new Array< int >();
                    RCArray< Text >* nachricht = new RCArray< Text >();
                    int anzahl = cs->zDB()->getChatNachrichten( accountId, vonAccount, nachricht );
                    CSKlient* c = cs->zSendeKlient( accountId );
                    if( c )
                    {
                        for( int i = 0; i < anzahl; i++ )
                            c->nachricht( vonAccount->get( i ), nachricht->z( i )->getText() );
                    }
                    vonAccount->leeren();
                    nachricht->release();
                    anzahl = cs->zDB()->getFreundschaftsAnfragen( accountId, vonAccount );
                    if( c )
                    {
                        for( int i = 0; i < anzahl; i++ )
                            c->freundesAnfrage( vonAccount->get( i ) );
                    }
                    vonAccount->release();
                }
                break;
            case 0x15: // ping
                if( 1 )
                {
                    if( !klientNummer )
                    {
                        errorZuKlient( "Du bist nicht Identifiziert." );
                        break;
                    }
                    klient->sendeEncrypted( "\1", 1 );
                    CSKlient* c = cs->zSendeKlient( accountId );
                    if( c )
                        c->keepAlive();
                }
                break;
            default:
                unbekannt++;
                errorZuKlient( "Unbekannte Nachricht!" );
                break;
            }
            if( br || unbekannt >= 10 )
                break;
            cs->addEmpfangen( klient->getDownloadBytes( 1 ) );
            cs->addGesendet( klient->getUploadBytes( 1 ) );
        }
    }
    cs->addEmpfangen( klient->getDownloadBytes( 1 ) );
    cs->addGesendet( klient->getUploadBytes( 1 ) );
    if( empfangen )
    {
        trenne();
        if( klientNummer )
        {
            if( accountId )
            {
                MSGWeiterleitung* weiter = new MSGWeiterleitung( dynamic_cast<ChatServer*>(cs->getThis()) );
                weiter->accountOffline( accountId );
                delete weiter;
            }
            cs->removeKlient( klientNummer );
        }
        else
            cs->removeKlient( this );
    }
}

bool CSKlient::kick()
{
    lock();
    if( empfangen )
    {
        klient->trenne();
        warteAufThread( 100 );
        ende();
        MSGWeiterleitung* weiter = new MSGWeiterleitung( dynamic_cast<ChatServer*>(cs->getThis()) );
        weiter->accountOffline( accountId );
        delete weiter;
    }
    else
    {
        klient->sendeEncrypted( "\1", 1 );
        Sleep( 100 );
        klient->trenne();
    }
    unlock();
    return 1;
}

bool CSKlient::nachricht( int vonAccount, const char* txt )
{
    if( empfangen )
        return 0;
    char len = (char)textLength( txt );
    if( len )
    {
        lock();
        klient->sendeEncrypted( "\4", 1 );
        klient->sendeEncrypted( (char*)&vonAccount, 4 );
        klient->sendeEncrypted( &len, 1 );
        klient->sendeEncrypted( txt, len );
        unlock();
    }
    cs->addEmpfangen( klient->getDownloadBytes( 1 ) );
    cs->addGesendet( klient->getUploadBytes( 1 ) );
    return 1;
}

bool CSKlient::gruppeEinladung( int vonAccount, int gruppeId )
{
    if( empfangen )
        return 0;
    lock();
    klient->sendeEncrypted( "\5", 1 );
    klient->sendeEncrypted( (char*)&vonAccount, 4 );
    klient->sendeEncrypted( (char*)&gruppeId, 4 );
    unlock();
    cs->addEmpfangen( klient->getDownloadBytes( 1 ) );
    cs->addGesendet( klient->getUploadBytes( 1 ) );
    return 1;
}

bool CSKlient::accountStatusChange( int account, const char* status )
{
    if( empfangen )
        return 0;
    char len = (char)(status ? textLength( status ) : 0);
    if( len )
    {
        lock();
        klient->sendeEncrypted( "\6", 1 );
        klient->sendeEncrypted( (char*)&account, 4 );
        klient->sendeEncrypted( &len, 1 );
        klient->sendeEncrypted( status, len );
        unlock();
    }
    cs->addEmpfangen( klient->getDownloadBytes( 1 ) );
    cs->addGesendet( klient->getUploadBytes( 1 ) );
    return 1;
}

bool CSKlient::accountNameChange( int account, const char* name )
{
    if( empfangen )
        return 0;
    char len = (char)(name ? textLength( name ) : 0);
    if( len )
    {
        lock();
        klient->sendeEncrypted( "\7", 1 );
        klient->sendeEncrypted( (char*)&account, 4 );
        klient->sendeEncrypted( &len, 1 );
        klient->sendeEncrypted( name, len );
        unlock();
    }
    cs->addEmpfangen( klient->getDownloadBytes( 1 ) );
    cs->addGesendet( klient->getUploadBytes( 1 ) );
    return 1;
}

bool CSKlient::keinFreundMehr( int account )
{
    if( empfangen )
        return 0;
    lock();
    klient->sendeEncrypted( "\x8", 1 );
    klient->sendeEncrypted( (char*)&account, 4 );
    unlock();
    cs->addEmpfangen( klient->getDownloadBytes( 1 ) );
    cs->addGesendet( klient->getUploadBytes( 1 ) );
    return 1;
}

bool CSKlient::freundesAnfrage( int vonAccount )
{
    if( empfangen )
        return 0;
    lock();
    klient->sendeEncrypted( "\x9", 1 );
    klient->sendeEncrypted( (char*)&vonAccount, 4 );
    unlock();
    cs->addEmpfangen( klient->getDownloadBytes( 1 ) );
    cs->addGesendet( klient->getUploadBytes( 1 ) );
    return 1;
}

bool CSKlient::neuerFreund( int account )
{
    if( empfangen )
        return 0;
    lock();
    klient->sendeEncrypted( "\xA", 1 );
    klient->sendeEncrypted( (char*)&account, 4 );
    unlock();
    cs->addEmpfangen( klient->getDownloadBytes( 1 ) );
    cs->addGesendet( klient->getUploadBytes( 1 ) );
    return 1;
}

bool CSKlient::freundesAnfrageAbgelehnt( int account )
{
    if( empfangen )
        return 0;
    lock();
    klient->sendeEncrypted( "\xB", 1 );
    klient->sendeEncrypted( (char*)&account, 4 );
    unlock();
    cs->addEmpfangen( klient->getDownloadBytes( 1 ) );
    cs->addGesendet( klient->getUploadBytes( 1 ) );
    return 1;
}

bool CSKlient::einladungZumChatroom( int vonAccount, int chatroomId )
{
    if( empfangen )
        return 0;
    lock();
    klient->sendeEncrypted( "\xC", 1 );
    klient->sendeEncrypted( (char*)&vonAccount, 4 );
    klient->sendeEncrypted( (char*)&chatroomId, 4 );
    unlock();
    cs->addEmpfangen( klient->getDownloadBytes( 1 ) );
    cs->addGesendet( klient->getUploadBytes( 1 ) );
    return 1;
}

bool CSKlient::einladungZumChatroomAbgelehnt( int account, int chatroomId )
{
    if( empfangen )
        return 0;
    lock();
    klient->sendeEncrypted( "\xD", 1 );
    klient->sendeEncrypted( (char*)&account, 4 );
    klient->sendeEncrypted( (char*)&chatroomId, 4 );
    unlock();
    cs->addEmpfangen( klient->getDownloadBytes( 1 ) );
    cs->addGesendet( klient->getUploadBytes( 1 ) );
    return 1;
}

bool CSKlient::spielerBetrittChatroom( int chatroomId, int account )
{
    if( empfangen )
        return 0;
    lock();
    klient->sendeEncrypted( "\xE", 1 );
    klient->sendeEncrypted( (char*)&chatroomId, 4 );
    klient->sendeEncrypted( (char*)&account, 4 );
    unlock();
    cs->addEmpfangen( klient->getDownloadBytes( 1 ) );
    cs->addGesendet( klient->getUploadBytes( 1 ) );
    return 1;
}

bool CSKlient::chatroomNachricht( int chatroomId, int vonAccount, const char* nachricht )
{
    if( empfangen )
        return 0;
    char len = (char)(nachricht ? textLength( nachricht ) : 0);
    if( len )
    {
        lock();
        klient->sendeEncrypted( "\xF", 1 );
        klient->sendeEncrypted( (char*)&chatroomId, 4 );
        klient->sendeEncrypted( (char*)&vonAccount, 4 );
        klient->sendeEncrypted( &len, 1 );
        klient->sendeEncrypted( nachricht, len );
        unlock();
    }
    cs->addEmpfangen( klient->getDownloadBytes( 1 ) );
    cs->addGesendet( klient->getUploadBytes( 1 ) );
    return 1;
}

bool CSKlient::spielerLeavesChatroom( int chatroomId, int accountId )
{
    if( empfangen )
        return 0;
    lock();
    klient->sendeEncrypted( "\x10", 1 );
    klient->sendeEncrypted( (char*)&chatroomId, 4 );
    klient->sendeEncrypted( (char*)&accountId, 4 );
    unlock();
    cs->addEmpfangen( klient->getDownloadBytes( 1 ) );
    cs->addGesendet( klient->getUploadBytes( 1 ) );
    return 1;
}

bool CSKlient::freunde( char anzahl, Array< int >* zAccountId )
{
    if( empfangen )
        return 0;
    lock();
    klient->sendeEncrypted( "\x11", 1 );
    klient->sendeEncrypted( &anzahl, 1 );
    for( int i = 0; i < anzahl; i++ )
    {
        int accId = zAccountId->get( i );
        klient->sendeEncrypted( (char*)&accId, 4 );
    }
    unlock();
    cs->addEmpfangen( klient->getDownloadBytes( 1 ) );
    cs->addGesendet( klient->getUploadBytes( 1 ) );
    return 1;
}

bool CSKlient::spielerImChatroom( int chatroomId, char anzahl, Array< int >* zAccountId )
{
    if( empfangen )
        return 0;
    lock();
    klient->sendeEncrypted( "\x12", 1 );
    klient->sendeEncrypted( (char*)&chatroomId, 4 );
    klient->sendeEncrypted( &anzahl, 1 );
    for( int i = 0; i < anzahl; i++ )
    {
        int accId = zAccountId->get( i );
        klient->sendeEncrypted( (char*)&accId, 4 );
    }
    unlock();
    cs->addEmpfangen( klient->getDownloadBytes( 1 ) );
    cs->addGesendet( klient->getUploadBytes( 1 ) );
    return 1;
}

bool CSKlient::freundOnline( int accountId )
{
    if( empfangen )
        return 0;
    lock();
    klient->sendeEncrypted( "\x13", 1 );
    klient->sendeEncrypted( (char*)&accountId, 4 );
    unlock();
    cs->addEmpfangen( klient->getDownloadBytes( 1 ) );
    cs->addGesendet( klient->getUploadBytes( 1 ) );
    return 1;
}

bool CSKlient::freundOffline( int accountId )
{
    if( empfangen )
        return 0;
    lock();
    klient->sendeEncrypted( "\x14", 1 );
    klient->sendeEncrypted( (char*)&accountId, 4 );
    unlock();
    cs->addEmpfangen( klient->getDownloadBytes( 1 ) );
    cs->addGesendet( klient->getUploadBytes( 1 ) );
    return 1;
}

bool CSKlient::chatroomAdmin( int chatroomId )
{
    if( empfangen )
        return 0;
    lock();
    klient->sendeEncrypted( "\x15", 1 );
    klient->sendeEncrypted( (char*)&chatroomId, 4 );
    unlock();
    cs->addEmpfangen( klient->getDownloadBytes( 1 ) );
    cs->addGesendet( klient->getUploadBytes( 1 ) );
    return 1;
}

bool CSKlient::chatroomKick( int chatroomId )
{
    if( empfangen )
        return 0;
    lock();
    klient->sendeEncrypted( "\x16", 1 );
    klient->sendeEncrypted( (char*)&chatroomId, 4 );
    unlock();
    cs->addEmpfangen( klient->getDownloadBytes( 1 ) );
    cs->addGesendet( klient->getUploadBytes( 1 ) );
    return 1;
}

bool CSKlient::spielerBertittGruppe( int accountId, int gruppeId )
{
    if( empfangen )
        return 0;
    lock();
    klient->sendeEncrypted( "\x17", 1 );
    klient->sendeEncrypted( (char*)&accountId, 4 );
    klient->sendeEncrypted( (char*)&gruppeId, 4 );
    unlock();
    cs->addEmpfangen( klient->getDownloadBytes( 1 ) );
    cs->addGesendet( klient->getUploadBytes( 1 ) );
    return 1;
}

bool CSKlient::spielerLeavesGruppe( int accountId, int gruppeId )
{
    if( empfangen )
        return 0;
    lock();
    klient->sendeEncrypted( "\x18", 1 );
    klient->sendeEncrypted( (char*)&accountId, 4 );
    klient->sendeEncrypted( (char*)&gruppeId, 4 );
    unlock();
    cs->addEmpfangen( klient->getDownloadBytes( 1 ) );
    cs->addGesendet( klient->getUploadBytes( 1 ) );
    return 1;
}

bool CSKlient::gruppeNachricht( int gruppeId, char* nachricht )
{
    if( empfangen )
        return 0;
    char len = (char)textLength( nachricht );
    if( !len )
        return 1;
    lock();
    klient->sendeEncrypted( "\x19", 1 );
    klient->sendeEncrypted( (char*)&gruppeId, 4 );
    klient->sendeEncrypted( &len, 1 );
    klient->sendeEncrypted( nachricht, len );
    unlock();
    cs->addEmpfangen( klient->getDownloadBytes( 1 ) );
    cs->addGesendet( klient->getUploadBytes( 1 ) );
    return 1;
}

bool CSKlient::gruppeAnmelden( int gruppeId )
{
    if( empfangen )
        return 0;
    lock();
    klient->sendeEncrypted( "\x1A", 1 );
    klient->sendeEncrypted( (char*)&gruppeId, 4 );
    unlock();
    cs->addEmpfangen( klient->getDownloadBytes( 1 ) );
    cs->addGesendet( klient->getUploadBytes( 1 ) );
    return 1;
}

bool CSKlient::gruppeAbmelden( int gruppeId )
{
    if( empfangen )
        return 0;
    lock();
    klient->sendeEncrypted( "\x1B", 1 );
    klient->sendeEncrypted( (char*)&gruppeId, 4 );
    unlock();
    cs->addEmpfangen( klient->getDownloadBytes( 1 ) );
    cs->addGesendet( klient->getUploadBytes( 1 ) );
    return 1;
}

bool CSKlient::gruppeSpielStarten( int gruppeId, bool starten )
{
    if( empfangen )
        return 0;
    lock();
    klient->sendeEncrypted( "\x1C", 1 );
    klient->sendeEncrypted( (char*)&gruppeId, 4 );
    if( starten )
        klient->sendeEncrypted( "\1", 1 );
    else
        klient->sendeEncrypted( "\0", 1 );
    unlock();
    cs->addEmpfangen( klient->getDownloadBytes( 1 ) );
    cs->addGesendet( klient->getUploadBytes( 1 ) );
    return 1;
}

bool CSKlient::setGruppeAdmin( int gruppeId, int adminId )
{
    if( empfangen )
        return 0;
    lock();
    klient->sendeEncrypted( "\x1E", 1 );
    klient->sendeEncrypted( (char*)&gruppeId, 4 );
    klient->sendeEncrypted( (char*)&adminId, 4 );
    unlock();
    cs->addEmpfangen( klient->getDownloadBytes( 1 ) );
    cs->addGesendet( klient->getUploadBytes( 1 ) );
    return 1;
}

bool CSKlient::kickAusGruppe( int gruppeId )
{
    if( empfangen )
        return 0;
    lock();
    klient->sendeEncrypted( "\x1D", 1 );
    klient->sendeEncrypted( (char*)&gruppeId, 4 );
    unlock();
    cs->addEmpfangen( klient->getDownloadBytes( 1 ) );
    cs->addGesendet( klient->getUploadBytes( 1 ) );
    return 1;
}

bool CSKlient::gruppeEinladungAbgelehnt( int gruppeId, int accountId )
{
    if( empfangen )
        return 0;
    lock();
    klient->sendeEncrypted( "\x1F", 1 );
    klient->sendeEncrypted( (char*)&gruppeId, 4 );
    klient->sendeEncrypted( (char*)&accountId, 4 );
    unlock();
    cs->addEmpfangen( klient->getDownloadBytes( 1 ) );
    cs->addGesendet( klient->getUploadBytes( 1 ) );
    return 1;
}

bool CSKlient::spielServerVerbindungsAnfrage( unsigned short port, unsigned char* ip )
{
    if( empfangen )
        return 0;
    lock();
    klient->sendeEncrypted( "\x20", 1 );
    klient->sendeEncrypted( (char*)&port, 2 );
    klient->sendeEncrypted( (char*)ip, 4 );
    unlock();
    cs->addEmpfangen( klient->getDownloadBytes( 1 ) );
    cs->addGesendet( klient->getUploadBytes( 1 ) );
    return 1;
}

bool CSKlient::gruppeEinladungAbgebrochen( int gruppeId, int accountId )
{
    if( empfangen )
        return 0;
    lock();
    klient->sendeEncrypted( "\x21", 1 );
    klient->sendeEncrypted( (char*)&gruppeId, 4 );
    klient->sendeEncrypted( (char*)&accountId, 4 );
    unlock();
    cs->addEmpfangen( klient->getDownloadBytes( 1 ) );
    cs->addGesendet( klient->getUploadBytes( 1 ) );
    return 1;
}

bool CSKlient::gruppeEinladungNeu( int gruppeId, int accountId )
{
    if( empfangen )
        return 0;
    lock();
    klient->sendeEncrypted( "\x22", 1 );
    klient->sendeEncrypted( (char*)&gruppeId, 4 );
    klient->sendeEncrypted( (char*)&accountId, 4 );
    unlock();
    cs->addEmpfangen( klient->getDownloadBytes( 1 ) );
    cs->addGesendet( klient->getUploadBytes( 1 ) );
    return 1;
}

bool CSKlient::errorZuKlient( const char* nachricht ) // sendet eine Fehlernachricht zum Klient
{
    char len = (char)textLength( nachricht );
    if( len )
    {
        lock();
        klient->sendeEncrypted( "\3", 1 );
        klient->sendeEncrypted( &len, 1 );
        klient->sendeEncrypted( nachricht, len );
        unlock();
    }
    cs->addEmpfangen( klient->getDownloadBytes( 1 ) );
    cs->addGesendet( klient->getUploadBytes( 1 ) );
    return 1;
}

bool CSKlient::keepAlive() // erhält die Verbindung aufrecht
{
    char res = 0;
    lock();
    klient->sendeEncrypted( "\x23", 1 );
    klient->getNachrichtEncrypted( &res, 1 );
    unlock();
    return res == 1;
}

void CSKlient::trenne()
{
    klient->trenne();
}

// constant
int CSKlient::getKlientNummer() const
{
    return klientNummer;
}

int CSKlient::getAccountId() const
{
    return accountId;
}

bool CSKlient::istEmpfang() const
{
    return empfangen;
}


// Inhalt der MSGWeiterleitung Klasse aus ChatServer.h
// Konstruktor
MSGWeiterleitung::MSGWeiterleitung( ChatServer* cs )
{
    klient = 0;
    this->cs = cs;
    letzterFehler = new Text( "" );
}

// Destruktor
MSGWeiterleitung::~MSGWeiterleitung()
{
    if( klient )
    {
        klient->trenne();
        klient->release();
    }
    letzterFehler->release();
    cs->release();
}

// nicht constant
bool MSGWeiterleitung::kickKlient( int accountId )
{
    bool ret = 1;
    int server = cs->zDB()->getChatServerId( accountId );
    if( server == cs->getId() )
    {
        CSKlient* klient = cs->zSendeKlient( accountId );
        if( klient )
        {
            ret = klient->kick();
            klient->trenne();
        }
        ret = ret & cs->removeAccount( accountId );
    }
    else
    {
        char* ip = 0;
        unsigned short port = 0;
        ret = cs->zDB()->getChatServerIpPort( server, &port, &ip );
        if( ip )
        {
            klient = new Klient();
            unsigned char key[ 20 ] = { 78, 20, 190, 133, 10, 175, 51, 96, 62, 1, 180, 194, 126, 50, 211, 154, 105, 227, 22, 101 };
            klient->setSendeKey( (char*)key, 20 );
            klient->setEmpfangKey( (char*)key, 20 );
            ret = ret & klient->verbinde( port, ip );
            ret = ret & klient->sendeEncrypted( "\5\1", 2 );
            char res = 0;
            ret = ret & klient->getNachrichtEncrypted( &res, 1 );
            if( res )
            {
                ret = ret & klient->sendeEncrypted( (char*)&accountId, 4 );
                ret = ret & klient->getNachrichtEncrypted( &res, 1 );
            }
            ret = (char)ret & res;
            cs->addEmpfangen( klient->getDownloadBytes( 1 ) );
            cs->addGesendet( klient->getUploadBytes( 1 ) );
            klient->trenne();
            klient = (Klient*)klient->release();
        }
        delete[]ip;
    }
    if( !ret )
        letzterFehler->setText( "Der Account ist nicht erreichbar" );
    return ret;
}

bool MSGWeiterleitung::accountOnline( int accountId )
{
    bool ret = 1;
    Array< int >* accId = new Array< int >();
    int anzahl = cs->zDB()->getAccountOnlineFreunde( accountId, accId );
    for( int i = 0; i < anzahl; i++ )
    {
        int account = accId->get( i );
        int server = cs->zDB()->getChatServerId( account );
        if( server == cs->getId() )
        {
            CSKlient* klient = cs->zSendeKlient( account );
            if( klient )
                ret = ret & klient->freundOnline( accountId );
            else
                ret = 0;
        }
        else
        {
            char* ip = 0;
            unsigned short port = 0;
            ret = ret & cs->zDB()->getChatServerIpPort( server, &port, &ip );
            if( ip )
            {
                klient = new Klient();
                unsigned char key[ 20 ] = { 78, 20, 190, 133, 10, 175, 51, 96, 62, 1, 180, 194, 126, 50, 211, 154, 105, 227, 22, 101 };
                klient->setSendeKey( (char*)key, 20 );
                klient->setEmpfangKey( (char*)key, 20 );
                ret = ret & klient->verbinde( port, ip );
                ret = ret & klient->sendeEncrypted( "\5\2", 2 );
                char res = 0;
                ret = ret & klient->getNachrichtEncrypted( &res, 1 );
                if( res )
                {
                    ret = ret & klient->sendeEncrypted( (char*)&accountId, 4 );
                    ret = ret & klient->sendeEncrypted( (char*)&account, 4 );
                    ret = ret & klient->getNachrichtEncrypted( &res, 1 );
                }
                ret = (char)ret & res;
                cs->addEmpfangen( klient->getDownloadBytes( 1 ) );
                cs->addGesendet( klient->getUploadBytes( 1 ) );
                klient->trenne();
                klient = (Klient*)klient->release();
            }
            delete[]ip;
        }
    }
    accId->release();
    if( !ret )
        letzterFehler->setText( "Einer oder mehr Accounts konnen nicht erreicht werden" );
    return ret;
}

bool MSGWeiterleitung::accountOffline( int accountId )
{
    bool ret = 1;
    Array< int >* accId = new Array< int >();
    int anzahl = cs->zDB()->getAccountOnlineFreunde( accountId, accId );
    for( int i = 0; i < anzahl; i++ )
    {
        int account = accId->get( i );
        int server = cs->zDB()->getChatServerId( account );
        if( server == cs->getId() )
        {
            CSKlient* klient = cs->zSendeKlient( account );
            if( klient )
                ret = ret & klient->freundOffline( accountId );
            else
                ret = 0;
        }
        else
        {
            char* ip = 0;
            unsigned short port = 0;
            ret = ret & cs->zDB()->getChatServerIpPort( server, &port, &ip );
            if( ip )
            {
                klient = new Klient();
                unsigned char key[ 20 ] = { 78, 20, 190, 133, 10, 175, 51, 96, 62, 1, 180, 194, 126, 50, 211, 154, 105, 227, 22, 101 };
                klient->setSendeKey( (char*)key, 20 );
                klient->setEmpfangKey( (char*)key, 20 );
                ret = ret & klient->verbinde( port, ip );
                ret = ret & klient->sendeEncrypted( "\5\3", 2 );
                char res = 0;
                ret = ret & klient->getNachrichtEncrypted( &res, 1 );
                if( res )
                {
                    ret = ret & klient->sendeEncrypted( (char*)&accountId, 4 );
                    ret = ret & klient->sendeEncrypted( (char*)&account, 4 );
                    ret = ret & klient->getNachrichtEncrypted( &res, 1 );
                }
                ret = (char)ret & res;
                cs->addEmpfangen( klient->getDownloadBytes( 1 ) );
                cs->addGesendet( klient->getUploadBytes( 1 ) );
                klient->trenne();
                klient = (Klient*)klient->release();
            }
            delete[]ip;
        }
    }
    accId->release();
    if( !ret )
        letzterFehler->setText( "Einer oder mehr Accounts konnen nicht erreicht werden" );
    return ret;
}

bool MSGWeiterleitung::chatNachricht( int vonAccount, int zuAccount, const char* nachricht )
{
    bool ret = 1;
    char len = (char)textLength( nachricht );
    if( !len )
        return 1;
    int server = cs->zDB()->getChatServerId( zuAccount );
    if( server == cs->getId() )
    {
        CSKlient* klient = cs->zSendeKlient( zuAccount );
        if( klient )
            ret = klient->nachricht( vonAccount, nachricht );
        else
            ret = 0;
    }
    else
    {
        char* ip = 0;
        unsigned short port = 0;
        ret = cs->zDB()->getChatServerIpPort( server, &port, &ip );
        if( ip )
        {
            klient = new Klient();
            unsigned char key[ 20 ] = { 78, 20, 190, 133, 10, 175, 51, 96, 62, 1, 180, 194, 126, 50, 211, 154, 105, 227, 22, 101 };
            klient->setSendeKey( (char*)key, 20 );
            klient->setEmpfangKey( (char*)key, 20 );
            ret = ret & klient->verbinde( port, ip );
            ret = ret & klient->sendeEncrypted( "\5\4", 2 );
            char res = 0;
            ret = ret & klient->getNachrichtEncrypted( (char*)&res, 1 );
            if( res )
            {
                ret = ret & klient->sendeEncrypted( (char*)&vonAccount, 4 );
                ret = ret & klient->sendeEncrypted( (char*)&zuAccount, 4 );
                ret = ret & klient->sendeEncrypted( &len, 1 );
                ret = ret & klient->sendeEncrypted( (char*)nachricht, len );
                ret = ret & klient->getNachrichtEncrypted( (char*)&res, 1 );
            }
            ret = (char)ret & res;
            cs->addEmpfangen( klient->getDownloadBytes( 1 ) );
            cs->addGesendet( klient->getUploadBytes( 1 ) );
            klient->trenne();
            klient = (Klient*)klient->release();
        }
        delete[]ip;
    }
    if( !ret )
        letzterFehler->setText( "Der Account konnte nicht erreicht werden. Die Nachricht wird zugestellt, sobald es möglich ist." );
    return ret;
}

bool MSGWeiterleitung::accountStatusChange( int accountId, const char* status )
{
    bool ret = 1;
    char len = (char)textLength( status );
    if( !len )
        return 1;
    Array< int >* accId = new Array< int >();
    int anzahl = cs->zDB()->getAccountOnlineFreunde( accountId, accId );
    for( int i = 0; i < anzahl; i++ )
    {
        int account = accId->get( i );
        int server = cs->zDB()->getChatServerId( account );
        if( server == cs->getId() )
        {
            CSKlient* klient = cs->zSendeKlient( account );
            if( klient )
                ret = ret & klient->accountStatusChange( accountId, status );
            else
                ret = 0;
        }
        else
        {
            char* ip = 0;
            unsigned short port = 0;
            ret = ret & cs->zDB()->getChatServerIpPort( server, &port, &ip );
            if( ip )
            {
                klient = new Klient();
                unsigned char key[ 20 ] = { 78, 20, 190, 133, 10, 175, 51, 96, 62, 1, 180, 194, 126, 50, 211, 154, 105, 227, 22, 101 };
                klient->setSendeKey( (char*)key, 20 );
                klient->setEmpfangKey( (char*)key, 20 );
                ret = ret & klient->verbinde( port, ip );
                ret = ret & klient->sendeEncrypted( "\5\6", 2 );
                char res = 0;
                ret = ret & klient->getNachrichtEncrypted( &res, 1 );
                if( res )
                {
                    ret = ret & klient->sendeEncrypted( (char*)&accountId, 4 );
                    ret = ret & klient->sendeEncrypted( (char*)&account, 4 );
                    ret = ret & klient->sendeEncrypted( (char*)&len, 1 );
                    ret = ret & klient->sendeEncrypted( (char*)status, len );
                    ret = ret & klient->getNachrichtEncrypted( &res, 1 );
                }
                ret = (char)ret & res;
                cs->addEmpfangen( klient->getDownloadBytes( 1 ) );
                cs->addGesendet( klient->getUploadBytes( 1 ) );
                klient->trenne();
                klient = (Klient*)klient->release();
            }
            delete[]ip;
        }
    }
    accId->release();
    if( !ret )
        letzterFehler->setText( "Einer oder mehr Accounts konnen nicht erreicht werden" );
    return ret;
}

bool MSGWeiterleitung::accountNameChange( int accountId, const char* name )
{
    bool ret = 1;
    char len = (char)textLength( name );
    if( !name )
        return 1;
    Array< int >* accId = new Array< int >();
    int anzahl = cs->zDB()->getAccountOnlineFreunde( accountId, accId );
    for( int i = 0; i < anzahl; i++ )
    {
        int account = accId->get( i );
        int server = cs->zDB()->getChatServerId( account );
        if( server == cs->getId() )
        {
            CSKlient* klient = cs->zSendeKlient( account );
            if( klient )
                ret = ret & klient->accountNameChange( accountId, name );
            else
                ret = 0;
        }
        else
        {
            char* ip = 0;
            unsigned short port = 0;
            ret = ret & cs->zDB()->getChatServerIpPort( server, &port, &ip );
            if( ip )
            {
                klient = new Klient();
                unsigned char key[ 20 ] = { 78, 20, 190, 133, 10, 175, 51, 96, 62, 1, 180, 194, 126, 50, 211, 154, 105, 227, 22, 101 };
                klient->setSendeKey( (char*)key, 20 );
                klient->setEmpfangKey( (char*)key, 20 );
                ret = ret & klient->verbinde( port, ip );
                ret = ret & klient->sendeEncrypted( "\5\7", 2 );
                char res = 0;
                ret = ret & klient->getNachrichtEncrypted( &res, 1 );
                if( res )
                {
                    ret = ret & klient->sendeEncrypted( (char*)&accountId, 4 );
                    ret = ret & klient->sendeEncrypted( (char*)&account, 4 );
                    ret = ret & klient->sendeEncrypted( (char*)&len, 1 );
                    ret = ret & klient->sendeEncrypted( (char*)name, len );
                    ret = ret & klient->getNachrichtEncrypted( &res, 1 );
                }
                ret = (char)ret & res;
                cs->addEmpfangen( klient->getDownloadBytes( 1 ) );
                cs->addGesendet( klient->getUploadBytes( 1 ) );
                klient->trenne();
                klient = (Klient*)klient->release();
            }
            delete[]ip;
        }
    }
    accId->release();
    if( !ret )
        letzterFehler->setText( "Einer oder mehr Accounts konnen nicht erreicht werden" );
    return ret;
}

bool MSGWeiterleitung::accountKeinFreundMehr( int accountId, int zielAccountId )
{
    bool ret = 1;
    int server = cs->zDB()->getChatServerId( zielAccountId );
    if( server == cs->getId() )
    {
        CSKlient* klient = cs->zSendeKlient( zielAccountId );
        if( klient )
            ret = ret & klient->keinFreundMehr( accountId );
        else
            ret = 0;
    }
    else
    {
        char* ip = 0;
        unsigned short port = 0;
        ret = cs->zDB()->getChatServerIpPort( server, &port, &ip );
        if( ip )
        {
            klient = new Klient();
            unsigned char key[ 20 ] = { 78, 20, 190, 133, 10, 175, 51, 96, 62, 1, 180, 194, 126, 50, 211, 154, 105, 227, 22, 101 };
            klient->setSendeKey( (char*)key, 20 );
            klient->setEmpfangKey( (char*)key, 20 );
            ret = ret & klient->verbinde( port, ip );
            ret = ret & klient->sendeEncrypted( "\5\x8", 2 );
            char res = 0;
            ret = ret & klient->getNachrichtEncrypted( &res, 1 );
            if( res )
            {
                ret = ret & klient->sendeEncrypted( (char*)&accountId, 4 );
                ret = ret & klient->sendeEncrypted( (char*)&zielAccountId, 4 );
                ret = ret & klient->getNachrichtEncrypted( &res, 1 );
            }
            ret = (char)ret & res;
            cs->addEmpfangen( klient->getDownloadBytes( 1 ) );
            cs->addGesendet( klient->getUploadBytes( 1 ) );
            klient->trenne();
            klient = (Klient*)klient->release();
        }
        delete[]ip;
    }
    if( !ret )
        letzterFehler->setText( "Der Account konnte nicht erreicht werden" );
    return ret;
}

bool MSGWeiterleitung::freundesAnfrage( int vonAccountId, int zuAccountId )
{
    bool ret = 1;
    int server = cs->zDB()->getChatServerId( zuAccountId );
    if( server == cs->getId() )
    {
        CSKlient* klient = cs->zSendeKlient( zuAccountId );
        if( klient )
            ret = ret & klient->freundesAnfrage( vonAccountId );
        else
            ret = 0;
    }
    else
    {
        char* ip = 0;
        unsigned short port = 0;
        ret = cs->zDB()->getChatServerIpPort( server, &port, &ip );
        if( ip )
        {
            klient = new Klient();
            unsigned char key[ 20 ] = { 78, 20, 190, 133, 10, 175, 51, 96, 62, 1, 180, 194, 126, 50, 211, 154, 105, 227, 22, 101 };
            klient->setSendeKey( (char*)key, 20 );
            klient->setEmpfangKey( (char*)key, 20 );
            ret = ret & klient->verbinde( port, ip );
            ret = ret & klient->sendeEncrypted( "\5\x9", 2 );
            char res = 0;
            ret = ret & klient->getNachrichtEncrypted( &res, 1 );
            if( res )
            {
                ret = ret & klient->sendeEncrypted( (char*)&vonAccountId, 4 );
                ret = ret & klient->sendeEncrypted( (char*)&zuAccountId, 4 );
                ret = ret & klient->getNachrichtEncrypted( &res, 1 );
            }
            ret = (char)ret & res;
            cs->addEmpfangen( klient->getDownloadBytes( 1 ) );
            cs->addGesendet( klient->getUploadBytes( 1 ) );
            klient->trenne();
            klient = (Klient*)klient->release();
        }
        delete[]ip;
    }
    if( !ret )
        letzterFehler->setText( "Der Account konnte nicht erreicht werden" );
    return ret;
}

bool MSGWeiterleitung::neuerFreund( int accountId, int zuAccountId )
{
    bool ret = 1;
    int server = cs->zDB()->getChatServerId( zuAccountId );
    if( server == cs->getId() )
    {
        CSKlient* klient = cs->zSendeKlient( zuAccountId );
        if( klient )
            ret = ret & klient->neuerFreund( accountId );
        else
            ret = 0;
    }
    else
    {
        char* ip = 0;
        unsigned short port = 0;
        ret = cs->zDB()->getChatServerIpPort( server, &port, &ip );
        if( ip )
        {
            klient = new Klient();
            unsigned char key[ 20 ] = { 78, 20, 190, 133, 10, 175, 51, 96, 62, 1, 180, 194, 126, 50, 211, 154, 105, 227, 22, 101 };
            klient->setSendeKey( (char*)key, 20 );
            klient->setEmpfangKey( (char*)key, 20 );
            ret = ret & klient->verbinde( port, ip );
            ret = ret & klient->sendeEncrypted( "\5\xA", 2 );
            char res = 0;
            ret = ret & klient->getNachrichtEncrypted( &res, 1 );
            if( res )
            {
                ret = ret & klient->sendeEncrypted( (char*)&accountId, 4 );
                ret = ret & klient->sendeEncrypted( (char*)&zuAccountId, 4 );
                ret = ret & klient->getNachrichtEncrypted( &res, 1 );
            }
            ret = (char)ret & res;
            cs->addEmpfangen( klient->getDownloadBytes( 1 ) );
            cs->addGesendet( klient->getUploadBytes( 1 ) );
            klient->trenne();
            klient = (Klient*)klient->release();
        }
        delete[]ip;
    }
    if( !ret )
        letzterFehler->setText( "Der Account konnte nicht erreicht werden" );
    return ret;
}

bool MSGWeiterleitung::einladungZumChatroom( int vonAccountId, int zuAccountId, int chatroomId )
{
    bool ret = 1;
    int server = cs->zDB()->getChatServerId( zuAccountId );
    if( server == cs->getId() )
    {
        CSKlient* klient = cs->zSendeKlient( zuAccountId );
        if( klient )
            ret = ret & klient->einladungZumChatroom( vonAccountId, chatroomId );
        else
            ret = 0;
    }
    else
    {
        char* ip = 0;
        unsigned short port = 0;
        ret = cs->zDB()->getChatServerIpPort( server, &port, &ip );
        if( ip )
        {
            klient = new Klient();
            unsigned char key[ 20 ] = { 78, 20, 190, 133, 10, 175, 51, 96, 62, 1, 180, 194, 126, 50, 211, 154, 105, 227, 22, 101 };
            klient->setSendeKey( (char*)key, 20 );
            klient->setEmpfangKey( (char*)key, 20 );
            ret = ret & klient->verbinde( port, ip );
            ret = ret & klient->sendeEncrypted( "\5\xB", 2 );
            char res = 0;
            ret = ret & klient->getNachrichtEncrypted( &res, 1 );
            if( res )
            {
                ret = ret & klient->sendeEncrypted( (char*)&vonAccountId, 4 );
                ret = ret & klient->sendeEncrypted( (char*)&zuAccountId, 4 );
                ret = ret & klient->sendeEncrypted( (char*)&chatroomId, 4 );
                ret = ret & klient->getNachrichtEncrypted( &res, 1 );
            }
            ret = (char)ret & res;
            cs->addEmpfangen( klient->getDownloadBytes( 1 ) );
            cs->addGesendet( klient->getUploadBytes( 1 ) );
            klient->trenne();
            klient = (Klient*)klient->release();
        }
        delete[]ip;
    }
    if( !ret )
        letzterFehler->setText( "Der Account konnte nicht erreicht werden" );
    return ret;
}

bool MSGWeiterleitung::spielerBetrittChatroom( int accountId, int chatroomId )
{
    bool ret = 1;
    Array< int >* accId = new Array< int >();
    int anzahl = cs->zDB()->getChatroomAccount( chatroomId, accId );
    for( int i = 0; i < anzahl; i++ )
    {
        int account = accId->get( i );
        if( account == accountId )
            continue;
        int server = cs->zDB()->getChatServerId( account );
        if( server == cs->getId() )
        {
            CSKlient* klient = cs->zSendeKlient( account );
            if( klient )
                ret = ret & klient->spielerBetrittChatroom( chatroomId, accountId );
            else
                ret = 0;
        }
        else
        {
            char* ip = 0;
            unsigned short port = 0;
            ret = ret & cs->zDB()->getChatServerIpPort( server, &port, &ip );
            if( ip )
            {
                klient = new Klient();
                unsigned char key[ 20 ] = { 78, 20, 190, 133, 10, 175, 51, 96, 62, 1, 180, 194, 126, 50, 211, 154, 105, 227, 22, 101 };
                klient->setSendeKey( (char*)key, 20 );
                klient->setEmpfangKey( (char*)key, 20 );
                ret = ret & klient->verbinde( port, ip );
                ret = ret & klient->sendeEncrypted( "\5\xC", 2 );
                char res = 0;
                ret = ret & klient->getNachrichtEncrypted( &res, 1 );
                if( res )
                {
                    ret = ret & klient->sendeEncrypted( (char*)&accountId, 4 );
                    ret = ret & klient->sendeEncrypted( (char*)&account, 4 );
                    ret = ret & klient->sendeEncrypted( (char*)&chatroomId, 4 );
                    ret = ret & klient->getNachrichtEncrypted( &res, 1 );
                }
                ret = (char)ret & res;
                cs->addEmpfangen( klient->getDownloadBytes( 1 ) );
                cs->addGesendet( klient->getUploadBytes( 1 ) );
                klient->trenne();
                klient = (Klient*)klient->release();
            }
            delete[]ip;
        }
    }
    accId->release();
    if( !ret )
        letzterFehler->setText( "Einer oder mehr Accounts konnen nicht erreicht werden" );
    return ret;
}

bool MSGWeiterleitung::chatroomNachricht( int vonAccount, const char* nachricht, int chatroomId )
{
    bool ret = 1;
    char len = (char)textLength( nachricht );
    if( !len )
        return 1;
    Array< int >* accId = new Array< int >();
    int anzahl = cs->zDB()->getChatroomAccount( chatroomId, accId );
    for( int i = 0; i < anzahl; i++ )
    {
        int account = accId->get( i );
        int server = cs->zDB()->getChatServerId( account );
        if( server == cs->getId() )
        {
            CSKlient* klient = cs->zSendeKlient( account );
            if( klient )
                ret = ret & klient->chatroomNachricht( chatroomId, vonAccount, nachricht );
            else
                ret = 0;
        }
        else
        {
            char* ip = 0;
            unsigned short port = 0;
            ret = ret & cs->zDB()->getChatServerIpPort( server, &port, &ip );
            if( ip )
            {
                klient = new Klient();
                unsigned char key[ 20 ] = { 78, 20, 190, 133, 10, 175, 51, 96, 62, 1, 180, 194, 126, 50, 211, 154, 105, 227, 22, 101 };
                klient->setSendeKey( (char*)key, 20 );
                klient->setEmpfangKey( (char*)key, 20 );
                ret = ret & klient->verbinde( port, ip );
                ret = ret & klient->sendeEncrypted( "\5\xD", 2 );
                char res = 0;
                ret = ret & klient->getNachrichtEncrypted( &res, 1 );
                if( res )
                {
                    ret = ret & klient->sendeEncrypted( (char*)&vonAccount, 4 );
                    ret = ret & klient->sendeEncrypted( (char*)&account, 4 );
                    ret = ret & klient->sendeEncrypted( (char*)&chatroomId, 4 );
                    ret = ret & klient->sendeEncrypted( &len, 1 );
                    ret = ret & klient->sendeEncrypted( (char*)nachricht, len );
                    ret = ret & klient->getNachrichtEncrypted( &res, 1 );
                }
                ret = (char)ret & res;
                cs->addEmpfangen( klient->getDownloadBytes( 1 ) );
                cs->addGesendet( klient->getUploadBytes( 1 ) );
                klient->trenne();
                klient = (Klient*)klient->release();
            }
            delete[]ip;
        }
    }
    accId->release();
    if( !ret )
        letzterFehler->setText( "Einer oder mehr Accounts konnen nicht erreicht werden" );
    return ret;
}

bool MSGWeiterleitung::spielerLeavestChatroom( int accountId, int chatroomId )
{
    bool ret = 1;
    Array< int >* accId = new Array< int >();
    int anzahl = cs->zDB()->getChatroomAccount( chatroomId, accId );
    for( int i = 0; i < anzahl; i++ )
    {
        int account = accId->get( i );
        int server = cs->zDB()->getChatServerId( account );
        if( server == cs->getId() )
        {
            CSKlient* klient = cs->zSendeKlient( account );
            if( klient )
                ret = ret & klient->spielerLeavesChatroom( chatroomId, accountId );
            else
                ret = 0;
        }
        else
        {
            char* ip = 0;
            unsigned short port = 0;
            ret = ret & cs->zDB()->getChatServerIpPort( server, &port, &ip );
            if( ip )
            {
                klient = new Klient();
                unsigned char key[ 20 ] = { 78, 20, 190, 133, 10, 175, 51, 96, 62, 1, 180, 194, 126, 50, 211, 154, 105, 227, 22, 101 };
                klient->setSendeKey( (char*)key, 20 );
                klient->setEmpfangKey( (char*)key, 20 );
                ret = ret & klient->verbinde( port, ip );
                ret = ret & klient->sendeEncrypted( "\5\xE", 2 );
                char res = 0;
                ret = ret & klient->getNachrichtEncrypted( &res, 1 );
                if( res )
                {
                    ret = ret & klient->sendeEncrypted( (char*)&accountId, 4 );
                    ret = ret & klient->sendeEncrypted( (char*)&account, 4 );
                    ret = ret & klient->sendeEncrypted( (char*)&chatroomId, 4 );
                    ret = ret & klient->getNachrichtEncrypted( &res, 1 );
                }
                ret = (char)ret & res;
                cs->addEmpfangen( klient->getDownloadBytes( 1 ) );
                cs->addGesendet( klient->getUploadBytes( 1 ) );
                klient->trenne();
                klient = (Klient*)klient->release();
            }
            delete[]ip;
        }
    }
    accId->release();
    if( !ret )
        letzterFehler->setText( "Einer oder mehr Accounts konnen nicht erreicht werden" );
    return ret;
}

bool MSGWeiterleitung::freundEinladungAbgelehnt( int accountId, int zuAccountId )
{
    bool ret = 1;
    int server = cs->zDB()->getChatServerId( zuAccountId );
    if( server == cs->getId() )
    {
        CSKlient* klient = cs->zSendeKlient( zuAccountId );
        if( klient )
            ret = ret & klient->freundesAnfrageAbgelehnt( accountId );
        else
            ret = 0;
    }
    else
    {
        char* ip = 0;
        unsigned short port = 0;
        ret = cs->zDB()->getChatServerIpPort( server, &port, &ip );
        if( ip )
        {
            klient = new Klient();
            unsigned char key[ 20 ] = { 78, 20, 190, 133, 10, 175, 51, 96, 62, 1, 180, 194, 126, 50, 211, 154, 105, 227, 22, 101 };
            klient->setSendeKey( (char*)key, 20 );
            klient->setEmpfangKey( (char*)key, 20 );
            ret = ret & klient->verbinde( port, ip );
            ret = ret & klient->sendeEncrypted( "\5\xF", 2 );
            char res = 0;
            ret = ret & klient->getNachrichtEncrypted( &res, 1 );
            if( res )
            {
                ret = ret & klient->sendeEncrypted( (char*)&accountId, 4 );
                ret = ret & klient->sendeEncrypted( (char*)&zuAccountId, 4 );
                ret = ret & klient->getNachrichtEncrypted( &res, 1 );
            }
            ret = (char)ret & res;
            cs->addEmpfangen( klient->getDownloadBytes( 1 ) );
            cs->addGesendet( klient->getUploadBytes( 1 ) );
            klient->trenne();
            klient = (Klient*)klient->release();
        }
        delete[]ip;
    }
    if( !ret )
        letzterFehler->setText( "Der Account konnte nicht erreicht werden" );
    return ret;
}

bool MSGWeiterleitung::chatroomEinladungAbgelehnt( int accountId, int chatroomId, int zuAccountId )
{
    bool ret = 1;
    int server = cs->zDB()->getChatServerId( zuAccountId );
    if( server == cs->getId() )
    {
        CSKlient* klient = cs->zSendeKlient( zuAccountId );
        if( klient )
            ret = ret & klient->einladungZumChatroomAbgelehnt( accountId, chatroomId );
        else
            ret = 0;
    }
    else
    {
        char* ip = 0;
        unsigned short port = 0;
        ret = cs->zDB()->getChatServerIpPort( server, &port, &ip );
        if( ip )
        {
            klient = new Klient();
            unsigned char key[ 20 ] = { 78, 20, 190, 133, 10, 175, 51, 96, 62, 1, 180, 194, 126, 50, 211, 154, 105, 227, 22, 101 };
            klient->setSendeKey( (char*)key, 20 );
            klient->setEmpfangKey( (char*)key, 20 );
            ret = ret & klient->verbinde( port, ip );
            ret = ret & klient->sendeEncrypted( "\5\x10", 2 );
            char res = 0;
            ret = ret & klient->getNachrichtEncrypted( &res, 1 );
            if( res )
            {
                ret = ret & klient->sendeEncrypted( (char*)&accountId, 4 );
                ret = ret & klient->sendeEncrypted( (char*)&zuAccountId, 4 );
                ret = ret & klient->sendeEncrypted( (char*)&chatroomId, 4 );
                ret = ret & klient->getNachrichtEncrypted( &res, 1 );
            }
            ret = (char)ret & res;
            cs->addEmpfangen( klient->getDownloadBytes( 1 ) );
            cs->addGesendet( klient->getUploadBytes( 1 ) );
            klient->trenne();
            klient = (Klient*)klient->release();
        }
        delete[]ip;
    }
    if( !ret )
        letzterFehler->setText( "Der Account konnte nicht erreicht werden" );
    return ret;
}

bool MSGWeiterleitung::fehler( int zuAccountId, const char* fehler )
{
    bool ret = 1;
    char len = (char)textLength( fehler );
    if( !len )
        return 1;
    int server = cs->zDB()->getChatServerId( zuAccountId );
    if( server == cs->getId() )
    {
        CSKlient* klient = cs->zSendeKlient( zuAccountId );
        if( klient )
            ret = ret & klient->errorZuKlient( fehler );
        else
            ret = 0;
    }
    else
    {
        char* ip = 0;
        unsigned short port = 0;
        ret = cs->zDB()->getChatServerIpPort( server, &port, &ip );
        if( ip )
        {
            klient = new Klient();
            unsigned char key[ 20 ] = { 78, 20, 190, 133, 10, 175, 51, 96, 62, 1, 180, 194, 126, 50, 211, 154, 105, 227, 22, 101 };
            klient->setSendeKey( (char*)key, 20 );
            klient->setEmpfangKey( (char*)key, 20 );
            ret = ret & klient->verbinde( port, ip );
            ret = ret & klient->sendeEncrypted( "\5\x11", 2 );
            char res = 0;
            ret = ret & klient->getNachrichtEncrypted( &res, 1 );
            if( res )
            {
                ret = ret & klient->sendeEncrypted( (char*)&zuAccountId, 4 );
                ret = ret & klient->sendeEncrypted( &len, 1 );
                ret = ret & klient->sendeEncrypted( (char*)&fehler, len );
                ret = ret & klient->getNachrichtEncrypted( &res, 1 );
            }
            ret = (char)ret & res;
            cs->addEmpfangen( klient->getDownloadBytes( 1 ) );
            cs->addGesendet( klient->getUploadBytes( 1 ) );
            klient->trenne();
            klient = (Klient*)klient->release();
        }
        delete[]ip;
    }
    if( !ret )
        letzterFehler->setText( "Der Account konnte nicht erreicht werden" );
    return ret;
}

bool MSGWeiterleitung::chatroomAdmin( int chatroomId, int zuAccountId )
{
    bool ret = 1;
    int server = cs->zDB()->getChatServerId( zuAccountId );
    if( server == cs->getId() )
    {
        CSKlient* klient = cs->zSendeKlient( zuAccountId );
        if( klient )
            ret = ret & klient->chatroomAdmin( chatroomId );
        else
            ret = 0;
    }
    else
    {
        char* ip = 0;
        unsigned short port = 0;
        ret = cs->zDB()->getChatServerIpPort( server, &port, &ip );
        if( ip )
        {
            klient = new Klient();
            unsigned char key[ 20 ] = { 78, 20, 190, 133, 10, 175, 51, 96, 62, 1, 180, 194, 126, 50, 211, 154, 105, 227, 22, 101 };
            klient->setSendeKey( (char*)key, 20 );
            klient->setEmpfangKey( (char*)key, 20 );
            ret = ret & klient->verbinde( port, ip );
            ret = ret & klient->sendeEncrypted( "\5\x12", 2 );
            char res = 0;
            ret = ret & klient->getNachrichtEncrypted( &res, 1 );
            if( res )
            {
                ret = ret & klient->sendeEncrypted( (char*)&zuAccountId, 4 );
                ret = ret & klient->sendeEncrypted( (char*)&chatroomId, 4 );
                ret = ret & klient->getNachrichtEncrypted( &res, 1 );
            }
            ret = (char)ret & res;
            cs->addEmpfangen( klient->getDownloadBytes( 1 ) );
            cs->addGesendet( klient->getUploadBytes( 1 ) );
            klient->trenne();
            klient = (Klient*)klient->release();
        }
        delete[]ip;
    }
    if( !ret )
        letzterFehler->setText( "Der Account konnte nicht erreicht werden" );
    return ret;
}

bool MSGWeiterleitung::chatroomKick( int chatroomId, int accountId )
{
    bool ret = 1;
    int server = cs->zDB()->getChatServerId( accountId );
    if( server == cs->getId() )
    {
        CSKlient* klient = cs->zSendeKlient( accountId );
        if( klient )
            ret = ret & klient->chatroomKick( chatroomId );
        else
            ret = 0;
    }
    else
    {
        char* ip = 0;
        unsigned short port = 0;
        ret = cs->zDB()->getChatServerIpPort( server, &port, &ip );
        if( ip )
        {
            klient = new Klient();
            unsigned char key[ 20 ] = { 78, 20, 190, 133, 10, 175, 51, 96, 62, 1, 180, 194, 126, 50, 211, 154, 105, 227, 22, 101 };
            klient->setSendeKey( (char*)key, 20 );
            klient->setEmpfangKey( (char*)key, 20 );
            ret = ret & klient->verbinde( port, ip );
            ret = ret & klient->sendeEncrypted( "\5\x13", 2 );
            char res = 0;
            ret = ret & klient->getNachrichtEncrypted( &res, 1 );
            if( res )
            {
                ret = ret & klient->sendeEncrypted( (char*)&accountId, 4 );
                ret = ret & klient->sendeEncrypted( (char*)&chatroomId, 4 );
                ret = ret & klient->getNachrichtEncrypted( &res, 1 );
            }
            ret = (char)ret & res;
            cs->addEmpfangen( klient->getDownloadBytes( 1 ) );
            cs->addGesendet( klient->getUploadBytes( 1 ) );
            klient->trenne();
            klient = (Klient*)klient->release();
        }
        delete[]ip;
    }
    if( !ret )
        letzterFehler->setText( "Der Account konnte nicht erreicht werden" );
    return ret;
}

// constant
const char* MSGWeiterleitung::getLetzterFehler()
{
    return letzterFehler->getText();
}