framework changes

AnmeldungServer/AnmeldungServer.cpp

@@ -5,1732 +5,1732 @@
 
 // Inhalt der AnmeldungServer Klasse aus AnmeldungServer.h
 // Konstruktor 
-AnmeldungServer::AnmeldungServer( InitDatei *zIni )
-    : Thread()
+AnmeldungServer::AnmeldungServer(InitDatei* zIni)
+	: Thread()
 {
-    Network::Start( 100 );
-    std::cout << "AS: Verbindung mit Datenbank wird hergestellt...\n";
-    db = new ASDatenbank( zIni );
-    klients = new RCArray< ASKlient >();
-    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 << "AS: Starten des Admin Servers...\n";
-    if( !aServer->verbinde( (unsigned short)TextZuInt( ini->zWert( "AdminServerPort" )->getText(), 10 ), 10 ) )
-    {
-        std::cout << "AS: Der Admin Server konnte nicht gestartet werden. Das Programm wird beendet.\n";
-        exit( 1 );
-    }
-    db->setServerStatus( id, 2 );
-    end = 0;
-    nichtPausiert = 0;
-    InitializeCriticalSection( &cs );
-    if( zIni->zWert( "Aktiv" )->istGleich( "TRUE" ) )
-    {
-        serverStarten();
-        serverFortsetzen();
-    }
+	Network::Start(100);
+	std::cout << "AS: Verbindung mit Datenbank wird hergestellt...\n";
+	db = new ASDatenbank(zIni);
+	klients = new RCArray< ASKlient >();
+	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 << "AS: Starten des Admin Servers...\n";
+	if (!aServer->verbinde((unsigned short)TextZuInt(ini->zWert("AdminServerPort")->getText(), 10), 10))
+	{
+		std::cout << "AS: Der Admin Server konnte nicht gestartet werden. Das Programm wird beendet.\n";
+		exit(1);
+	}
+	db->setServerStatus(id, 2);
+	end = 0;
+	nichtPausiert = 0;
+	InitializeCriticalSection(&cs);
+	if (zIni->zWert("Aktiv")->istGleich("TRUE"))
+	{
+		serverStarten();
+		serverFortsetzen();
+	}
 }
 
 // Destruktor 
 AnmeldungServer::~AnmeldungServer()
 {
-    fehler->release();
-    server->trenne();
-    server->release();
-    aServer->trenne();
-    aServer->release();
-    if( klients )
-        klients->release();
-    ini->release();
-    db->release();
-    DeleteCriticalSection( &cs );
+	fehler->release();
+	server->trenne();
+	server->release();
+	aServer->trenne();
+	aServer->release();
+	if (klients)
+		klients->release();
+	ini->release();
+	db->release();
+	DeleteCriticalSection(&cs);
 }
 
 // nicht constant 
 void AnmeldungServer::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;
-        ASAKlient *clHandle = new ASAKlient( klient, dynamic_cast<AnmeldungServer *>( getThis() ) );
-        clHandle->start();
-    }
+	while (!end && aServer->isConnected())
+	{
+		SSLSKlient* klient;
+		klient = aServer->getKlient();
+		if (end && klient)
+		{
+			klient->trenne();
+			klient = (SSLSKlient*)klient->release();
+			Sleep(1000);
+			return;
+		}
+		if (!klient)
+			continue;
+		ASAKlient* clHandle = new ASAKlient(klient, dynamic_cast<AnmeldungServer*>(getThis()));
+		clHandle->start();
+	}
 }
 
 void AnmeldungServer::thread()
 {
-    while( server->isConnected() )
-    {
-        SKlient *klient;
-        klient = server->getKlient();
-        if( !klient )
-            continue;
-        Framework::getThreadRegister()->cleanUpClosedThreads();
-        ASKlient *clHandle = new ASKlient( klient, dynamic_cast<AnmeldungServer *>( getThis() ) );
-        EnterCriticalSection( &cs );
-        klients->add( clHandle );
-        LeaveCriticalSection( &cs );
-        clHandle->start();
-    }
+	while (server->isConnected())
+	{
+		SKlient* klient;
+		klient = server->getKlient();
+		if (!klient)
+			continue;
+		Framework::getThreadRegister()->cleanUpClosedThreads();
+		ASKlient* clHandle = new ASKlient(klient, dynamic_cast<AnmeldungServer*>(getThis()));
+		EnterCriticalSection(&cs);
+		klients->add(clHandle);
+		LeaveCriticalSection(&cs);
+		clHandle->start();
+	}
 }
 
 void AnmeldungServer::close()
 {
-    db->setServerStatus( id, 1 );
-    server->trenne();
+	db->setServerStatus(id, 1);
+	server->trenne();
 #ifdef WIN32
-    warteAufThread( 1000 );
+	warteAufThread(1000);
 #endif
-    EnterCriticalSection( &cs );
-    for( ASKlient *client : *klients )
-        client->absturz();
-    klients = ( RCArray<ASKlient>* )klients->release();
-    LeaveCriticalSection( &cs );
-    ende();
-    run = 0;
-    end = 1;
-    Klient *klient = new Klient();
-    klient->verbinde( aServer->getPort(), "127.0.0.1" );
-    Sleep( 500 );
-    aServer->trenne();
-    klient->release();
+	EnterCriticalSection(&cs);
+	for (ASKlient* client : *klients)
+		client->absturz();
+	klients = (RCArray<ASKlient>*)klients->release();
+	LeaveCriticalSection(&cs);
+	ende();
+	run = 0;
+	end = 1;
+	Klient* klient = new Klient();
+	klient->verbinde(aServer->getPort(), "127.0.0.1");
+	Sleep(500);
+	aServer->trenne();
+	klient->release();
 }
 
 bool AnmeldungServer::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;
-    }
+	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 AnmeldungServer::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;
+	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 AnmeldungServer::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;
+	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 AnmeldungServer::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;
+	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 AnmeldungServer::setMaxKlients( int mc )
+bool AnmeldungServer::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;
-    }
-    return 1;
+	if (!db->setMaxClients(id, mc))
+	{
+		fehler->setText("Die maximale Anzahl der Clients konnte nicht gesetzt werden:\n");
+		fehler->append(db->getLetzterFehler());
+		return 0;
+	}
+	return 1;
 }
 
-bool AnmeldungServer::absturzKlient( int klientId )
+bool AnmeldungServer::absturzKlient(int klientId)
 {
-    bool gefunden = 0;
-    EnterCriticalSection( &cs );
-    for( int i = 0; i < klients->getEintragAnzahl(); i++ )
-    {
-        if( klients->z( i )->getKlientNummer() == klientId )
-        {
-            klients->z( i )->absturz();
-            klients->remove( i );
-            gefunden = 1;
-            break;
-        }
-    }
-    LeaveCriticalSection( &cs );
-    return gefunden;
+	bool gefunden = 0;
+	EnterCriticalSection(&cs);
+	for (int i = 0; i < klients->getEintragAnzahl(); i++)
+	{
+		if (klients->z(i)->getKlientNummer() == klientId)
+		{
+			klients->z(i)->absturz();
+			klients->remove(i);
+			gefunden = 1;
+			break;
+		}
+	}
+	LeaveCriticalSection(&cs);
+	return gefunden;
 }
 
-bool AnmeldungServer::removeKlient( ASKlient *zKlient )
+bool AnmeldungServer::removeKlient(ASKlient* zKlient)
 {
-    bool gefunden = 0;
-    EnterCriticalSection( &cs );
-    for( int i = 0; i < klients->getEintragAnzahl(); i++ )
-    {
-        if( klients->z( i ) == zKlient )
-        {
-            klients->remove( i );
-            gefunden = 1;
-            break;
-        }
-    }
-    LeaveCriticalSection( &cs );
-    return gefunden;
+	bool gefunden = 0;
+	EnterCriticalSection(&cs);
+	for (int i = 0; i < klients->getEintragAnzahl(); i++)
+	{
+		if (klients->z(i) == zKlient)
+		{
+			klients->remove(i);
+			gefunden = 1;
+			break;
+		}
+	}
+	LeaveCriticalSection(&cs);
+	return gefunden;
 }
 
-void AnmeldungServer::addGesendet( int bytes )
+void AnmeldungServer::addGesendet(int bytes)
 {
-    gesendet += bytes;
+	gesendet += bytes;
 }
 
-void AnmeldungServer::addEmpfangen( int bytes )
+void AnmeldungServer::addEmpfangen(int bytes)
 {
-    empfangen += bytes;
+	empfangen += bytes;
 }
 
 // constant 
 bool AnmeldungServer::istAn() const
 {
-    return db->serverIstNichtPausiert( id );
+	return db->serverIstNichtPausiert(id);
 }
 
-Server *AnmeldungServer::zServer() const
+Server* AnmeldungServer::zServer() const
 {
-    return server;
+	return server;
 }
 
-ASDatenbank *AnmeldungServer::zDB() const
+ASDatenbank* AnmeldungServer::zDB() const
 {
-    return db;
+	return db;
 }
 
 bool AnmeldungServer::hatClients() const
 {
-    return klients->hat(0);
+	return klients->hat(0);
 }
 
 int AnmeldungServer::getId() const
 {
-    return id;
+	return id;
 }
 
-char *AnmeldungServer::getLetzterFehler() const
+const char* AnmeldungServer::getLetzterFehler() const
 {
-    return fehler->getText();
+	return fehler->getText();
 }
 
-char *AnmeldungServer::getIp() const
+const char* AnmeldungServer::getIp() const
 {
-    return ini->zWert( "ServerIp" )->getText();
+	return ini->zWert("ServerIp")->getText();
 }
 
 
 // Inhalt der ASAKlient Klasse aus AnmeldungServer.h
 // Konstruktor 
-ASAKlient::ASAKlient( SSLSKlient *klient, AnmeldungServer *as )
-    : Thread()
+ASAKlient::ASAKlient(SSLSKlient* klient, AnmeldungServer* as)
+	: Thread()
 {
-    this->klient = klient;
-    name = new Text( "" );
-    passwort = new Text( "" );
-    adminId = 0;
-    version = 0;
-    this->as = as;
+	this->klient = klient;
+	name = new Text("");
+	passwort = new Text("");
+	adminId = 0;
+	version = 0;
+	this->as = as;
 }
 
 // Destruktor 
 ASAKlient::~ASAKlient()
 {
-    klient->trenne();
-    klient->release();
-    as->release();
-    name->release();
-    passwort->release();
+	klient->trenne();
+	klient->release();
+	as->release();
+	name->release();
+	passwort->release();
 }
 
 // nicht constant 
 void ASAKlient::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 = as->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( as->zDB()->adminHatRecht( adminId, Admin_Recht::ASStarten ) )
-                    {
-                        if( !as->serverStarten() )
-                        {
-                            Text *err = new Text();
-                            err->append( as->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( as->zDB()->adminHatRecht( adminId, Admin_Recht::ASBeenden ) )
-                    {
-                        if( as->serverBeenden() )
-                            klient->sende( "\1", 1 );
-                        else
-                        {
-                            Text *err = new Text();
-                            err->append( as->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( as->isRunning() )
-                    {
-                        if( as->zDB()->adminHatRecht( adminId, Admin_Recht::ASBeenden ) )
-                        {
-                            if( as->serverBeenden() )
-                                ok = 1;
-                            else
-                            {
-                                Text *err = new Text();
-                                err->append( as->getLetzterFehler() );
-                                errorZuKlient( err->getText() );
-                                err->release();
-                            }
-                        }
-                        else
-                            errorZuKlient( "Du bist nicht berechtigt den Server zu beenden." );
-                    }
-                    else
-                        ok = 1;
-                    if( ok && as->hatClients() )
-                    {
-                        errorZuKlient( "Es sind noch Klients Online. Bitte versuche es später erneut." );
-                        break;
-                    }
-                    if( ok )
-                    {
-                        klient->sende( "\1", 1 );
-                        std::cout << "AS: Der Server wird von Benutzer " << adminId << " heruntergefahren.\n";
-                        as->close();
-                        br = 1;
-                    }
-                }
-                break;
-            case 7: // Progtamm abstürzen
-                if( !adminId )
-                    errorZuKlient( "Du musst dich einloggen." );
-                else
-                {
-                    bool ok = 0;
-                    if( as->isRunning() )
-                    {
-                        if( as->zDB()->adminHatRecht( adminId, Admin_Recht::ASBeenden ) )
-                        {
-                            as->serverBeenden();
-                            ok = 1;
-                        }
-                        else
-                            errorZuKlient( "Du bist nicht berechtigt den Server zu beenden." );
-                    }
-                    else
-                        ok = 1;
-                    if( ok )
-                    {
-                        klient->sende( "\1", 1 );
-                        std::cout << "AS: Der Server wurde von Benutzer " << adminId << " terminiert.\n";
-                        as->close();
-                        br = 1;
-                    }
-                }
-                break;
-            case 8: // Status Frage
-                if( 1 )
-                {
-                    char status = 0;
-                    if( as->isRunning() )
-                    {
-                        status = 1;
-                        if( as->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( as->zDB()->adminHatRecht( adminId, Admin_Recht::ASPausieren ) )
-                    {
-                        bool ok = 0;
-                        if( pause )
-                            ok = as->serverPause();
-                        else
-                            ok = as->serverFortsetzen();
-                        if( ok )
-                            klient->sende( "\1", 1 );
-                        else
-                        {
-                            Text *err = new Text();
-                            err->append( as->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( as->zDB()->adminHatRecht( adminId, Admin_Recht::ASMCChange ) )
-                    {
-                        if( as->setMaxKlients( maxC ) )
-                            klient->sende( "\1", 1 );
-                        else
-                        {
-                            Text *err = new Text();
-                            err->append( as->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 && as->absturzKlient( klientId ) )
-                        klient->sende( "\1", 1 );
-                    else
-                        klient->sende( "\0", 1 );
-                }
-                break;
-            default:
-                errorZuKlient( "Unbekannte Nachricht!" );
-                break;
-            }
-            if( br )
-                break;
-            as->addEmpfangen( klient->getDownloadBytes( 1 ) );
-            as->addGesendet( klient->getUploadBytes( 1 ) );
-        }
-    }
-    as->addEmpfangen( klient->getDownloadBytes( 1 ) );
-    as->addGesendet( klient->getUploadBytes( 1 ) );
-    delete this;
+	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 = as->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 (as->zDB()->adminHatRecht(adminId, Admin_Recht::ASStarten))
+					{
+						if (!as->serverStarten())
+						{
+							Text* err = new Text();
+							err->append(as->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 (as->zDB()->adminHatRecht(adminId, Admin_Recht::ASBeenden))
+					{
+						if (as->serverBeenden())
+							klient->sende("\1", 1);
+						else
+						{
+							Text* err = new Text();
+							err->append(as->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 (as->isRunning())
+					{
+						if (as->zDB()->adminHatRecht(adminId, Admin_Recht::ASBeenden))
+						{
+							if (as->serverBeenden())
+								ok = 1;
+							else
+							{
+								Text* err = new Text();
+								err->append(as->getLetzterFehler());
+								errorZuKlient(err->getText());
+								err->release();
+							}
+						}
+						else
+							errorZuKlient("Du bist nicht berechtigt den Server zu beenden.");
+					}
+					else
+						ok = 1;
+					if (ok && as->hatClients())
+					{
+						errorZuKlient("Es sind noch Klients Online. Bitte versuche es später erneut.");
+						break;
+					}
+					if (ok)
+					{
+						klient->sende("\1", 1);
+						std::cout << "AS: Der Server wird von Benutzer " << adminId << " heruntergefahren.\n";
+						as->close();
+						br = 1;
+					}
+				}
+				break;
+			case 7: // Progtamm abstürzen
+				if (!adminId)
+					errorZuKlient("Du musst dich einloggen.");
+				else
+				{
+					bool ok = 0;
+					if (as->isRunning())
+					{
+						if (as->zDB()->adminHatRecht(adminId, Admin_Recht::ASBeenden))
+						{
+							as->serverBeenden();
+							ok = 1;
+						}
+						else
+							errorZuKlient("Du bist nicht berechtigt den Server zu beenden.");
+					}
+					else
+						ok = 1;
+					if (ok)
+					{
+						klient->sende("\1", 1);
+						std::cout << "AS: Der Server wurde von Benutzer " << adminId << " terminiert.\n";
+						as->close();
+						br = 1;
+					}
+				}
+				break;
+			case 8: // Status Frage
+				if (1)
+				{
+					char status = 0;
+					if (as->isRunning())
+					{
+						status = 1;
+						if (as->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 (as->zDB()->adminHatRecht(adminId, Admin_Recht::ASPausieren))
+					{
+						bool ok = 0;
+						if (pause)
+							ok = as->serverPause();
+						else
+							ok = as->serverFortsetzen();
+						if (ok)
+							klient->sende("\1", 1);
+						else
+						{
+							Text* err = new Text();
+							err->append(as->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 (as->zDB()->adminHatRecht(adminId, Admin_Recht::ASMCChange))
+					{
+						if (as->setMaxKlients(maxC))
+							klient->sende("\1", 1);
+						else
+						{
+							Text* err = new Text();
+							err->append(as->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 && as->absturzKlient(klientId))
+						klient->sende("\1", 1);
+					else
+						klient->sende("\0", 1);
+				}
+				break;
+			default:
+				errorZuKlient("Unbekannte Nachricht!");
+				break;
+			}
+			if (br)
+				break;
+			as->addEmpfangen(klient->getDownloadBytes(1));
+			as->addGesendet(klient->getUploadBytes(1));
+		}
+	}
+	as->addEmpfangen(klient->getDownloadBytes(1));
+	as->addGesendet(klient->getUploadBytes(1));
+	delete this;
 }
 
-void ASAKlient::errorZuKlient( const char *nachricht ) const // sendet eine Fehlernachricht zum Klient
+void ASAKlient::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 );
+	klient->sende("\3", 1);
+	char len = (char)textLength(nachricht);
+	klient->sende(&len, 1);
+	klient->sende(nachricht, len);
 }
 
 
 // Inhalt der ASKlient aus AnmeldungServer.h
 // Konstruktor
-ASKlient::ASKlient( SKlient *klient, AnmeldungServer *as )
-    : Thread()
+ASKlient::ASKlient(SKlient* klient, AnmeldungServer* as)
+	: Thread()
 {
-    this->klient = klient;
-    unsigned char key[ 20 ] = { 158, 10, 37, 155, 117, 58, 28, 197, 132, 76, 252, 83, 84, 222, 11, 125, 240, 218, 25, 201 };
-    klient->setSendeKey( (char *)key, 20 );
-    klient->setEmpfangKey( (char *)key, 20 );
-    klientNummer = 0;
-    this->as = as;
-    accountId = 0;
+	this->klient = klient;
+	unsigned char key[20] = { 158, 10, 37, 155, 117, 58, 28, 197, 132, 76, 252, 83, 84, 222, 11, 125, 240, 218, 25, 201 };
+	klient->setSendeKey((char*)key, 20);
+	klient->setEmpfangKey((char*)key, 20);
+	klientNummer = 0;
+	this->as = as;
+	accountId = 0;
 }
 
 // Destruktor 
 ASKlient::~ASKlient()
 {
-    klient->release();
-    as->release();
+	klient->release();
+	as->release();
 }
 
 // nicht constant 
 void ASKlient::absturz()
 {
-    ende();
-    klient->trenne();
-    as->zDB()->unregisterKlient( klientNummer, as->getId() );
+	ende();
+	klient->trenne();
+	as->zDB()->unregisterKlient(klientNummer, as->getId());
 }
 
 void ASKlient::thread()
 {
-    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( !as->zDB()->proveKlient( klientNummer, as->getId() ) )
-                {
-                    klientNummer = 0;
-                    errorZuKlient( "Du bist nicht für diesen Server eingetragen" );
-                }
-                else
-                {
-                    accountId = as->zDB()->getAccountId( klientNummer );
-                    if( accountId )
-                    {
-                        Text *key = as->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();
-                        }
-                    }
-                    else
-                    {
-                        klientNummer = 0;
-                        errorZuKlient( "Du bist nicht eingeloggt." );
-                    }
-                }
-                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 && as->absturzKlient( klientId ) )
-                                klient->sendeEncrypted( "\1", 1 );
-                            else
-                                klient->sendeEncrypted( "\0", 1 );
-                        }
-                        break;
-                    default:
-                        errorZuKlient( "Befehl nicht bekannt!" );
-                        break;
-                    }
-                }
-                break;
-            case 3: // Verbindungsende
-                br = 1;
-                klient->sendeEncrypted( "\1", 1 );
-                break;
-            case 4: // unregister Klient
-                if( !klientNummer )
-                {
-                    errorZuKlient( "Du bist nicht Identifiziert." );
-                    break;
-                }
-                as->zDB()->unregisterKlient( klientNummer, as->getId() );
-                klient->sendeEncrypted( "\1", 1 );
-                break;
-            case 5: // gruppe erstellen
-                if( 1 )
-                {
-                    if( !klientNummer )
-                    {
-                        errorZuKlient( "Du bist nicht Identifiziert." );
-                        break;
-                    }
-                    klient->sendeEncrypted( "\1", 1 );
-                    int karteId = 0;
-                    klient->getNachrichtEncrypted( (char *)&karteId, 4 );
-                    int gruppeId = 0;
-                    int ret = as->zDB()->gruppeErstellen( accountId, karteId, &gruppeId );
-                    switch( ret )
-                    {
-                    case 0:
-                        errorZuKlient( "Du bist nicht eingeloggt." );
-                        break;
-                    case 1:
-                        errorZuKlient( "Du wurdest bereits einem Spiel zugeordnet." );
-                        break;
-                    case 2:
-                        errorZuKlient( "Du bist in einem anderen noch laufendem Spiel. Spiele es zu Ende." );
-                        break;
-                    case 3:
-                        errorZuKlient( "Du bist in einer anderen Gruppe." );
-                        break;
-                    case 4:
-                        errorZuKlient( "Du bist bereits in der Warteschlange." );
-                        break;
-                    case 5:
-                        errorZuKlient( "Die Karte ist zur Zeit nicht spielbar." );
-                        break;
-                    case 6:
-                        errorZuKlient( "Unbekannter Fehler." );
-                        break;
-                    case 7:
-                        klient->sendeEncrypted( "\1", 1 );
-                        klient->sendeEncrypted( (char *)&gruppeId, 4 );
-                        break;
-                    }
-                }
-                break;
-            case 6: // gruppe betreten
-                if( 1 )
-                {
-                    if( !klientNummer )
-                    {
-                        errorZuKlient( "Du bist nicht Identifiziert." );
-                        break;
-                    }
-                    klient->sendeEncrypted( "\1", 1 );
-                    int gruppeId = 0;
-                    klient->getNachrichtEncrypted( (char *)&gruppeId, 4 );
-                    if( as->zDB()->gruppeIstInWarteschlange( gruppeId ) )
-                    {
-                        errorZuKlient( "Die Gruppe befindet sich bereits in der Warteschlange." );
-                        break;
-                    }
-                    if( !as->zDB()->gruppeSpielerIstEingeladen( gruppeId, accountId ) )
-                    {
-                        errorZuKlient( "Du bist nicht mehr eingeladen." );
-                        break;
-                    }
-                    int anzahl = 0;
-                    Array< int > *accIds = new Array< int >();
-                    as->zDB()->getSpielerInGruppe( gruppeId, accIds, &anzahl );
-                    int res = as->zDB()->gruppeBetreten( accountId, gruppeId );
-                    switch( res )
-                    {
-                    case 0:
-                        errorZuKlient( "Du bist nicht eingeloggt." );
-                        break;
-                    case 1:
-                        errorZuKlient( "Du wurdest bereits einem Spiel zugeordnet." );
-                        break;
-                    case 2:
-                        errorZuKlient( "Du bist in einem anderen noch laufendem Spiel. Spiele es zu Ende." );
-                        break;
-                    case 3:
-                        errorZuKlient( "Du bist in einer anderen Gruppe." );
-                        break;
-                    case 4:
-                        errorZuKlient( "Du bist bereits in der Warteschlange." );
-                        break;
-                    case 5:
-                        errorZuKlient( "Die Gruppe ist bereits in einem Spiel." );
-                        break;
-                    case 6:
-                        errorZuKlient( "Unbekannter Fehler." );
-                        break;
-                    case 7:
-                        if( 1 )
-                        {
-                            klient->sendeEncrypted( "\1", 1 );
-                            klient->sendeEncrypted( (char *)&anzahl, 4 );
-                            for( int i = 0; i < anzahl; i++ )
-                            {
-                                int id = accIds->get( i );
-                                if( id == accountId )
-                                    continue;
-                                klient->sendeEncrypted( (char *)&id, 4 );
-                            }
-                            as->zDB()->gruppeEinladungAbbrechen( as->zDB()->getGruppeAdminId( gruppeId ), gruppeId, accountId );
-                            MsgWeiterleitung *weiter = new MsgWeiterleitung( accountId, dynamic_cast<AnmeldungServer *>( as->getThis() ) );
-                            weiter->spielerBetrittGruppe( gruppeId );
-                            weiter->release();
-                        }
-                        break;
-                    }
-                    accIds->release();
-                }
-                break;
-            case 7: // gruppe verlassen
-                if( 1 )
-                {
-                    if( !klientNummer )
-                    {
-                        errorZuKlient( "Du bist nicht Identifiziert." );
-                        break;
-                    }
-                    klient->sendeEncrypted( "\1", 1 );
-                    int gruppeId = 0;
-                    klient->getNachrichtEncrypted( (char *)&gruppeId, 4 );
-                    if( as->zDB()->gruppeIstInWarteschlange( gruppeId ) )
-                    {
-                        errorZuKlient( "Die Gruppe befindet sich bereits in der Warteschlange." );
-                        break;
-                    }
-                    int ret = as->zDB()->gruppeVerlassen( accountId, gruppeId );
-                    if( !ret )
-                        errorZuKlient( "Du kannst die gruppe momentan nicht mehr verlassen." );
-                    if( ret == 1 )
-                    {
-                        klient->sendeEncrypted( "\1", 1 );
-                        MsgWeiterleitung *weiter = new MsgWeiterleitung( accountId, dynamic_cast<AnmeldungServer *>( as->getThis() ) );
-                        weiter->spielerLeavesGruppe( gruppeId );
-                        weiter->release();
-                    }
-                    if( ret == 2 )
-                        klient->sendeEncrypted( "\1", 1 );
-                    if( ret == 3 )
-                    {
-                        klient->sendeEncrypted( "\1", 1 );
-                        int adminId = as->zDB()->getGruppeAdminId( gruppeId );
-                        MsgWeiterleitung *weiter = new MsgWeiterleitung( accountId, dynamic_cast<AnmeldungServer *>( as->getThis() ) );
-                        weiter->setGruppeAdmin( gruppeId, adminId );
-                        weiter->spielerLeavesGruppe( gruppeId );
-                        weiter->release();
-                    }
-                    if( ret == 4 )
-                    {
-                        klient->sendeEncrypted( "\1", 1 );
-                        Array< int > *spieler = new Array< int >();
-                        int anzahl = 0;
-                        MsgWeiterleitung *weiter = new MsgWeiterleitung( accountId, dynamic_cast<AnmeldungServer *>( as->getThis() ) );
-                        if( as->zDB()->getSpielerInGruppe( gruppeId, spieler, &anzahl ) )
-                        {
-                            for( int i = 0; i < anzahl; i++ )
-                            {
-                                if( spieler->hat( i ) )
-                                {
-                                    weiter->kickSpielerAusGruppe( spieler->get( i ), gruppeId );
-                                    as->zDB()->gruppeVerlassen( spieler->get( i ), gruppeId );
-                                }
-                            }
-                        }
-                        spieler->release();
-                        weiter->release();
-                    }
-                }
-                break;
-            case 9: // gruppe anmelden
-                if( 1 )
-                {
-                    if( !klientNummer )
-                    {
-                        errorZuKlient( "Du bist nicht Identifiziert." );
-                        break;
-                    }
-                    klient->sendeEncrypted( "\1", 1 );
-                    int gruppeId = 0;
-                    klient->getNachrichtEncrypted( (char *)&gruppeId, 4 );
-                    if( !as->zDB()->spielerBesitztKarte( accountId, as->zDB()->getGruppenKarte( gruppeId ) ) )
-                    {
-                        errorZuKlient( "Du besitzt entweder die Karte oder das Spiel nicht." );
-                        break;
-                    }
-                    if( as->zDB()->getGruppeSpielStarten( gruppeId ) && as->zDB()->getSpielerInGruppeAnzahl( gruppeId ) <= 1 )
-                    {
-                        errorZuKlient( "Es müssen mindestens 2 Spieler in der Gruppe vorhanden sein." );
-                        break;
-                    }
-                    if( as->zDB()->gruppeAnmelden( accountId, gruppeId ) )
-                    {
-                        klient->sendeEncrypted( "\1", 1 );
-                        MsgWeiterleitung *weiter = new MsgWeiterleitung( accountId, dynamic_cast<AnmeldungServer *>( as->getThis() ) );
-                        weiter->gruppeAngemeldet( gruppeId );
-                        weiter->release();
-                    }
-                    else
-                        errorZuKlient( "Du kannst die Gruppe nicht anmelden." );
-                }
-                break;
-            case 0xA: // gruppe abmelden
-                if( 1 )
-                {
-                    if( !klientNummer )
-                    {
-                        errorZuKlient( "Du bist nicht Identifiziert." );
-                        break;
-                    }
-                    klient->sendeEncrypted( "\1", 1 );
-                    int gruppeId = 0;
-                    klient->getNachrichtEncrypted( (char *)&gruppeId, 4 );
-                    if( as->zDB()->gruppeAbmelden( accountId, gruppeId ) )
-                    {
-                        klient->sendeEncrypted( "\1", 1 );
-                        MsgWeiterleitung *weiter = new MsgWeiterleitung( accountId, dynamic_cast<AnmeldungServer *>( as->getThis() ) );
-                        weiter->gruppeAbgemeldet( gruppeId );
-                        weiter->release();
-                    }
-                    else
-                        errorZuKlient( "Du kannst die Gruppe nicht abmelden." );
-                    break;
-                }
-            case 0xB: // spieler einladen
-                if( 1 )
-                {
-                    if( !klientNummer )
-                    {
-                        errorZuKlient( "Du bist nicht Identifiziert." );
-                        break;
-                    }
-                    klient->sendeEncrypted( "\1", 1 );
-                    int gruppeId = 0;
-                    int zuAccountId = 0;
-                    klient->getNachrichtEncrypted( (char *)&zuAccountId, 4 );
-                    klient->getNachrichtEncrypted( (char *)&gruppeId, 4 );
-                    if( as->zDB()->gruppeIstInWarteschlange( gruppeId ) )
-                    {
-                        errorZuKlient( "Die Gruppe befindet sich bereits in der Warteschlange." );
-                        break;
-                    }
-                    if( as->zDB()->gruppeSpielerEinladen( accountId, zuAccountId, gruppeId ) )
-                    {
-                        MsgWeiterleitung *weiter = new MsgWeiterleitung( accountId, dynamic_cast<AnmeldungServer *>( as->getThis() ) );
-                        if( weiter->spielEinladung( gruppeId, zuAccountId ) )
-                            klient->sendeEncrypted( "\1", 1 );
-                        else
-                        {
-                            if( weiter->zLetzterFehler()->getLength() )
-                                errorZuKlient( weiter->zLetzterFehler()->getText() );
-                            else
-                                errorZuKlient( "Fehler beim zuteilen der Einladung." );
-                        }
-                        weiter->release();
-                    }
-                    else
-                        errorZuKlient( "Du kannst diesen Spieler nicht einladen." );
-                }
-                break;
-            case 0xC: // spieler kicken
-                if( 1 )
-                {
-                    if( !klientNummer )
-                    {
-                        errorZuKlient( "Du bist nicht Identifiziert." );
-                        break;
-                    }
-                    klient->sendeEncrypted( "\1", 1 );
-                    int gruppeId = 0;
-                    int zuAccountId = 0;
-                    klient->getNachrichtEncrypted( (char *)&zuAccountId, 4 );
-                    klient->getNachrichtEncrypted( (char *)&gruppeId, 4 );
-                    if( as->zDB()->gruppeIstInWarteschlange( gruppeId ) )
-                    {
-                        errorZuKlient( "Die Gruppe befindet sich bereits in der Warteschlange." );
-                        break;
-                    }
-                    if( as->zDB()->spielerKannKicken( accountId, gruppeId ) )
-                    {
-                        klient->sendeEncrypted( "\1", 1 );
-                        as->zDB()->gruppeVerlassen( zuAccountId, gruppeId );
-                        MsgWeiterleitung *weiter = new MsgWeiterleitung( zuAccountId, dynamic_cast<AnmeldungServer *>( as->getThis() ) );
-                        weiter->kickSpielerAusGruppe( zuAccountId, gruppeId );
-                        weiter->spielerLeavesGruppe( gruppeId );
-                        weiter->release();
-                    }
-                    else
-                        errorZuKlient( "Du hast keine berechtigung diesen Spieler zu kicken." );
-                }
-                break;
-            case 0xD: // gruppen Nachricht senden
-                if( 1 )
-                {
-                    if( !klientNummer )
-                    {
-                        errorZuKlient( "Du bist nicht Identifiziert." );
-                        break;
-                    }
-                    klient->sendeEncrypted( "\1", 1 );
-                    int gruppeId = 0;
-                    unsigned char key = 0;
-                    klient->getNachrichtEncrypted( (char *)&gruppeId, 4 );
-                    klient->getNachrichtEncrypted( (char *)&key, 1 );
-                    char *nachricht = new char[ key + 1 ];
-                    nachricht[ (int)key ] = 0;
-                    if( key )
-                        klient->getNachrichtEncrypted( nachricht, key );
-                    else
-                    {
-                        klient->sendeEncrypted( "\1", 1 );
-                        delete[] nachricht;
-                        break;
-                    }
-                    klient->sendeEncrypted( "\1", 1 );
-                    Text *message = as->zDB()->getAccountRufName( accountId );
-                    message->append( ": " );
-                    message->append( nachricht );
-                    delete[] nachricht;
-                    MsgWeiterleitung *weiter = new MsgWeiterleitung( accountId, dynamic_cast<AnmeldungServer *>( as->getThis() ) );
-                    weiter->gruppenNachricht( gruppeId, message->getText() );
-                    weiter->release();
-                    message->release();
-                }
-                break;
-            case 0xE: // spieler anmelden
-                if( 1 )
-                {
-                    if( !klientNummer )
-                    {
-                        errorZuKlient( "Du bist nicht Identifiziert." );
-                        break;
-                    }
-                    klient->sendeEncrypted( "\1", 1 );
-                    int karteId = 0;
-                    klient->getNachrichtEncrypted( (char *)&karteId, 4 );
-                    if( !as->zDB()->spielerBesitztKarte( accountId, karteId ) )
-                    {
-                        errorZuKlient( "Du besitzt entweder die Karte oder das Spiel nicht." );
-                        break;
-                    }
-                    int ret = as->zDB()->accountAnmelden( accountId, karteId );
-                    switch( ret )
-                    {
-                    case 0:
-                        errorZuKlient( "Du bist nicht eingeloggt." );
-                        break;
-                    case 1:
-                        errorZuKlient( "Du wurdest bereits einem Spiel zugeordnet." );
-                        break;
-                    case 2:
-                        errorZuKlient( "Du bist in einem anderen noch laufendem Spiel. Spiele es zu Ende." );
-                        break;
-                    case 3:
-                        errorZuKlient( "Du bist in einer anderen Gruppe." );
-                        break;
-                    case 4:
-                        errorZuKlient( "Du bist bereits in der Warteschlange." );
-                        break;
-                    case 5:
-                        errorZuKlient( "Die Karte ist zur Zeit nicht spielbar." );
-                        break;
-                    case 6:
-                        errorZuKlient( "Unbekannter Fehler." );
-                        break;
-                    case 7:
-                        klient->sendeEncrypted( "\1", 1 );
-                        break;
-                    }
-                }
-                break;
-            case 0xF: // spieler abmelden
-                if( !klientNummer )
-                {
-                    errorZuKlient( "Du bist nicht Identifiziert." );
-                    break;
-                }
-                klient->sendeEncrypted( "\1", 1 );
-                as->zDB()->accountAbmelden( accountId );
-                break;
-            case 0x10: // gruppe Spiel Starten
-                if( 1 )
-                {
-                    if( !klientNummer )
-                    {
-                        errorZuKlient( "Du bist nicht Identifiziert." );
-                        break;
-                    }
-                    klient->sendeEncrypted( "\1", 1 );
-                    char spielStarten = 0;
-                    int gruppeId = 0;
-                    klient->getNachrichtEncrypted( (char *)&gruppeId, 4 );
-                    klient->getNachrichtEncrypted( &spielStarten, 1 );
-                    if( spielStarten && as->zDB()->getSpielerInGruppeAnzahl( gruppeId ) < 2 )
-                    {
-                        errorZuKlient( "Es müssen sich mindestens 2 Spieler in der Gruppe befinden." );
-                        break;
-                    }
-                    if( as->zDB()->setGruppeSpielStarten( accountId, gruppeId, spielStarten == 1 ) )
-                    {
-                        klient->sendeEncrypted( "\1", 1 );
-                        MsgWeiterleitung *weiter = new MsgWeiterleitung( accountId, dynamic_cast<AnmeldungServer *>( as->getThis() ) );
-                        weiter->gruppeSpielStarten( gruppeId, spielStarten == 1 );
-                        weiter->release();
-                    }
-                    else
-                        errorZuKlient( "Du kannst diese Option nicht setzen." );
-                }
-                break;
-            case 0x11: // gruppe Einladung abbrechen
-                if( 1 )
-                {
-                    if( !klientNummer )
-                    {
-                        errorZuKlient( "Du bist nicht Identifiziert." );
-                        break;
-                    }
-                    klient->sendeEncrypted( "\1", 1 );
-                    int gruppeId = 0;
-                    int accountId = 0;
-                    klient->getNachrichtEncrypted( (char *)&gruppeId, 4 );
-                    klient->getNachrichtEncrypted( (char *)&accountId, 4 );
-                    if( as->zDB()->gruppeEinladungAbbrechen( this->accountId, gruppeId, accountId ) )
-                    {
-                        klient->sendeEncrypted( "\1", 1 );
-                        MsgWeiterleitung *weiter = new MsgWeiterleitung( accountId, dynamic_cast<AnmeldungServer *>( as->getThis() ) );
-                        weiter->spielEinladungAbbrechen( gruppeId, accountId );
-                        weiter->release();
-                    }
-                    else
-                        errorZuKlient( "Du kannst diese Option nicht setzen." );
-                }
-                break;
-            case 0x12: // gruppe Einladung ablehnen
-                if( 1 )
-                {
-                    if( !klientNummer )
-                    {
-                        errorZuKlient( "Du bist nicht Identifiziert." );
-                        break;
-                    }
-                    klient->sendeEncrypted( "\1", 1 );
-                    int gruppeId = 0;
-                    klient->getNachrichtEncrypted( (char *)&gruppeId, 4 );
-                    klient->sendeEncrypted( "\1", 1 );
-                    as->zDB()->gruppeEinladungAbbrechen( as->zDB()->getGruppeAdminId( gruppeId ), gruppeId, accountId );
-                    MsgWeiterleitung *weiter = new MsgWeiterleitung( accountId, dynamic_cast<AnmeldungServer *>( as->getThis() ) );
-                    weiter->spielEinladungAblehnen( gruppeId );
-                    weiter->release();
-                }
-                break;
-            case 0x13: // ping
-                if( 1 )
-                {
-                    if( !klientNummer )
-                    {
-                        errorZuKlient( "Du bist nicht Identifiziert." );
-                        break;
-                    }
-                    klient->sendeEncrypted( "\1", 1 );
-                }
-                break;
-            default:
-                errorZuKlient( "Unbekannte Nachricht!" );
-                break;
-            }
-            if( br )
-                break;
-            as->addEmpfangen( klient->getDownloadBytes( 1 ) );
-            as->addGesendet( klient->getUploadBytes( 1 ) );
-        }
-    }
-    as->addEmpfangen( klient->getDownloadBytes( 1 ) );
-    as->addGesendet( klient->getUploadBytes( 1 ) );
-    as->removeKlient( this ); // delete this
+	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 (!as->zDB()->proveKlient(klientNummer, as->getId()))
+				{
+					klientNummer = 0;
+					errorZuKlient("Du bist nicht für diesen Server eingetragen");
+				}
+				else
+				{
+					accountId = as->zDB()->getAccountId(klientNummer);
+					if (accountId)
+					{
+						Text* key = as->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();
+						}
+					}
+					else
+					{
+						klientNummer = 0;
+						errorZuKlient("Du bist nicht eingeloggt.");
+					}
+				}
+				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 && as->absturzKlient(klientId))
+								klient->sendeEncrypted("\1", 1);
+							else
+								klient->sendeEncrypted("\0", 1);
+						}
+						break;
+					default:
+						errorZuKlient("Befehl nicht bekannt!");
+						break;
+					}
+				}
+				break;
+			case 3: // Verbindungsende
+				br = 1;
+				klient->sendeEncrypted("\1", 1);
+				break;
+			case 4: // unregister Klient
+				if (!klientNummer)
+				{
+					errorZuKlient("Du bist nicht Identifiziert.");
+					break;
+				}
+				as->zDB()->unregisterKlient(klientNummer, as->getId());
+				klient->sendeEncrypted("\1", 1);
+				break;
+			case 5: // gruppe erstellen
+				if (1)
+				{
+					if (!klientNummer)
+					{
+						errorZuKlient("Du bist nicht Identifiziert.");
+						break;
+					}
+					klient->sendeEncrypted("\1", 1);
+					int karteId = 0;
+					klient->getNachrichtEncrypted((char*)&karteId, 4);
+					int gruppeId = 0;
+					int ret = as->zDB()->gruppeErstellen(accountId, karteId, &gruppeId);
+					switch (ret)
+					{
+					case 0:
+						errorZuKlient("Du bist nicht eingeloggt.");
+						break;
+					case 1:
+						errorZuKlient("Du wurdest bereits einem Spiel zugeordnet.");
+						break;
+					case 2:
+						errorZuKlient("Du bist in einem anderen noch laufendem Spiel. Spiele es zu Ende.");
+						break;
+					case 3:
+						errorZuKlient("Du bist in einer anderen Gruppe.");
+						break;
+					case 4:
+						errorZuKlient("Du bist bereits in der Warteschlange.");
+						break;
+					case 5:
+						errorZuKlient("Die Karte ist zur Zeit nicht spielbar.");
+						break;
+					case 6:
+						errorZuKlient("Unbekannter Fehler.");
+						break;
+					case 7:
+						klient->sendeEncrypted("\1", 1);
+						klient->sendeEncrypted((char*)&gruppeId, 4);
+						break;
+					}
+				}
+				break;
+			case 6: // gruppe betreten
+				if (1)
+				{
+					if (!klientNummer)
+					{
+						errorZuKlient("Du bist nicht Identifiziert.");
+						break;
+					}
+					klient->sendeEncrypted("\1", 1);
+					int gruppeId = 0;
+					klient->getNachrichtEncrypted((char*)&gruppeId, 4);
+					if (as->zDB()->gruppeIstInWarteschlange(gruppeId))
+					{
+						errorZuKlient("Die Gruppe befindet sich bereits in der Warteschlange.");
+						break;
+					}
+					if (!as->zDB()->gruppeSpielerIstEingeladen(gruppeId, accountId))
+					{
+						errorZuKlient("Du bist nicht mehr eingeladen.");
+						break;
+					}
+					int anzahl = 0;
+					Array< int >* accIds = new Array< int >();
+					as->zDB()->getSpielerInGruppe(gruppeId, accIds, &anzahl);
+					int res = as->zDB()->gruppeBetreten(accountId, gruppeId);
+					switch (res)
+					{
+					case 0:
+						errorZuKlient("Du bist nicht eingeloggt.");
+						break;
+					case 1:
+						errorZuKlient("Du wurdest bereits einem Spiel zugeordnet.");
+						break;
+					case 2:
+						errorZuKlient("Du bist in einem anderen noch laufendem Spiel. Spiele es zu Ende.");
+						break;
+					case 3:
+						errorZuKlient("Du bist in einer anderen Gruppe.");
+						break;
+					case 4:
+						errorZuKlient("Du bist bereits in der Warteschlange.");
+						break;
+					case 5:
+						errorZuKlient("Die Gruppe ist bereits in einem Spiel.");
+						break;
+					case 6:
+						errorZuKlient("Unbekannter Fehler.");
+						break;
+					case 7:
+						if (1)
+						{
+							klient->sendeEncrypted("\1", 1);
+							klient->sendeEncrypted((char*)&anzahl, 4);
+							for (int i = 0; i < anzahl; i++)
+							{
+								int id = accIds->get(i);
+								if (id == accountId)
+									continue;
+								klient->sendeEncrypted((char*)&id, 4);
+							}
+							as->zDB()->gruppeEinladungAbbrechen(as->zDB()->getGruppeAdminId(gruppeId), gruppeId, accountId);
+							MsgWeiterleitung* weiter = new MsgWeiterleitung(accountId, dynamic_cast<AnmeldungServer*>(as->getThis()));
+							weiter->spielerBetrittGruppe(gruppeId);
+							weiter->release();
+						}
+						break;
+					}
+					accIds->release();
+				}
+				break;
+			case 7: // gruppe verlassen
+				if (1)
+				{
+					if (!klientNummer)
+					{
+						errorZuKlient("Du bist nicht Identifiziert.");
+						break;
+					}
+					klient->sendeEncrypted("\1", 1);
+					int gruppeId = 0;
+					klient->getNachrichtEncrypted((char*)&gruppeId, 4);
+					if (as->zDB()->gruppeIstInWarteschlange(gruppeId))
+					{
+						errorZuKlient("Die Gruppe befindet sich bereits in der Warteschlange.");
+						break;
+					}
+					int ret = as->zDB()->gruppeVerlassen(accountId, gruppeId);
+					if (!ret)
+						errorZuKlient("Du kannst die gruppe momentan nicht mehr verlassen.");
+					if (ret == 1)
+					{
+						klient->sendeEncrypted("\1", 1);
+						MsgWeiterleitung* weiter = new MsgWeiterleitung(accountId, dynamic_cast<AnmeldungServer*>(as->getThis()));
+						weiter->spielerLeavesGruppe(gruppeId);
+						weiter->release();
+					}
+					if (ret == 2)
+						klient->sendeEncrypted("\1", 1);
+					if (ret == 3)
+					{
+						klient->sendeEncrypted("\1", 1);
+						int adminId = as->zDB()->getGruppeAdminId(gruppeId);
+						MsgWeiterleitung* weiter = new MsgWeiterleitung(accountId, dynamic_cast<AnmeldungServer*>(as->getThis()));
+						weiter->setGruppeAdmin(gruppeId, adminId);
+						weiter->spielerLeavesGruppe(gruppeId);
+						weiter->release();
+					}
+					if (ret == 4)
+					{
+						klient->sendeEncrypted("\1", 1);
+						Array< int >* spieler = new Array< int >();
+						int anzahl = 0;
+						MsgWeiterleitung* weiter = new MsgWeiterleitung(accountId, dynamic_cast<AnmeldungServer*>(as->getThis()));
+						if (as->zDB()->getSpielerInGruppe(gruppeId, spieler, &anzahl))
+						{
+							for (int i = 0; i < anzahl; i++)
+							{
+								if (spieler->hat(i))
+								{
+									weiter->kickSpielerAusGruppe(spieler->get(i), gruppeId);
+									as->zDB()->gruppeVerlassen(spieler->get(i), gruppeId);
+								}
+							}
+						}
+						spieler->release();
+						weiter->release();
+					}
+				}
+				break;
+			case 9: // gruppe anmelden
+				if (1)
+				{
+					if (!klientNummer)
+					{
+						errorZuKlient("Du bist nicht Identifiziert.");
+						break;
+					}
+					klient->sendeEncrypted("\1", 1);
+					int gruppeId = 0;
+					klient->getNachrichtEncrypted((char*)&gruppeId, 4);
+					if (!as->zDB()->spielerBesitztKarte(accountId, as->zDB()->getGruppenKarte(gruppeId)))
+					{
+						errorZuKlient("Du besitzt entweder die Karte oder das Spiel nicht.");
+						break;
+					}
+					if (as->zDB()->getGruppeSpielStarten(gruppeId) && as->zDB()->getSpielerInGruppeAnzahl(gruppeId) <= 1)
+					{
+						errorZuKlient("Es müssen mindestens 2 Spieler in der Gruppe vorhanden sein.");
+						break;
+					}
+					if (as->zDB()->gruppeAnmelden(accountId, gruppeId))
+					{
+						klient->sendeEncrypted("\1", 1);
+						MsgWeiterleitung* weiter = new MsgWeiterleitung(accountId, dynamic_cast<AnmeldungServer*>(as->getThis()));
+						weiter->gruppeAngemeldet(gruppeId);
+						weiter->release();
+					}
+					else
+						errorZuKlient("Du kannst die Gruppe nicht anmelden.");
+				}
+				break;
+			case 0xA: // gruppe abmelden
+				if (1)
+				{
+					if (!klientNummer)
+					{
+						errorZuKlient("Du bist nicht Identifiziert.");
+						break;
+					}
+					klient->sendeEncrypted("\1", 1);
+					int gruppeId = 0;
+					klient->getNachrichtEncrypted((char*)&gruppeId, 4);
+					if (as->zDB()->gruppeAbmelden(accountId, gruppeId))
+					{
+						klient->sendeEncrypted("\1", 1);
+						MsgWeiterleitung* weiter = new MsgWeiterleitung(accountId, dynamic_cast<AnmeldungServer*>(as->getThis()));
+						weiter->gruppeAbgemeldet(gruppeId);
+						weiter->release();
+					}
+					else
+						errorZuKlient("Du kannst die Gruppe nicht abmelden.");
+					break;
+				}
+			case 0xB: // spieler einladen
+				if (1)
+				{
+					if (!klientNummer)
+					{
+						errorZuKlient("Du bist nicht Identifiziert.");
+						break;
+					}
+					klient->sendeEncrypted("\1", 1);
+					int gruppeId = 0;
+					int zuAccountId = 0;
+					klient->getNachrichtEncrypted((char*)&zuAccountId, 4);
+					klient->getNachrichtEncrypted((char*)&gruppeId, 4);
+					if (as->zDB()->gruppeIstInWarteschlange(gruppeId))
+					{
+						errorZuKlient("Die Gruppe befindet sich bereits in der Warteschlange.");
+						break;
+					}
+					if (as->zDB()->gruppeSpielerEinladen(accountId, zuAccountId, gruppeId))
+					{
+						MsgWeiterleitung* weiter = new MsgWeiterleitung(accountId, dynamic_cast<AnmeldungServer*>(as->getThis()));
+						if (weiter->spielEinladung(gruppeId, zuAccountId))
+							klient->sendeEncrypted("\1", 1);
+						else
+						{
+							if (weiter->zLetzterFehler()->getLength())
+								errorZuKlient(weiter->zLetzterFehler()->getText());
+							else
+								errorZuKlient("Fehler beim zuteilen der Einladung.");
+						}
+						weiter->release();
+					}
+					else
+						errorZuKlient("Du kannst diesen Spieler nicht einladen.");
+				}
+				break;
+			case 0xC: // spieler kicken
+				if (1)
+				{
+					if (!klientNummer)
+					{
+						errorZuKlient("Du bist nicht Identifiziert.");
+						break;
+					}
+					klient->sendeEncrypted("\1", 1);
+					int gruppeId = 0;
+					int zuAccountId = 0;
+					klient->getNachrichtEncrypted((char*)&zuAccountId, 4);
+					klient->getNachrichtEncrypted((char*)&gruppeId, 4);
+					if (as->zDB()->gruppeIstInWarteschlange(gruppeId))
+					{
+						errorZuKlient("Die Gruppe befindet sich bereits in der Warteschlange.");
+						break;
+					}
+					if (as->zDB()->spielerKannKicken(accountId, gruppeId))
+					{
+						klient->sendeEncrypted("\1", 1);
+						as->zDB()->gruppeVerlassen(zuAccountId, gruppeId);
+						MsgWeiterleitung* weiter = new MsgWeiterleitung(zuAccountId, dynamic_cast<AnmeldungServer*>(as->getThis()));
+						weiter->kickSpielerAusGruppe(zuAccountId, gruppeId);
+						weiter->spielerLeavesGruppe(gruppeId);
+						weiter->release();
+					}
+					else
+						errorZuKlient("Du hast keine berechtigung diesen Spieler zu kicken.");
+				}
+				break;
+			case 0xD: // gruppen Nachricht senden
+				if (1)
+				{
+					if (!klientNummer)
+					{
+						errorZuKlient("Du bist nicht Identifiziert.");
+						break;
+					}
+					klient->sendeEncrypted("\1", 1);
+					int gruppeId = 0;
+					unsigned char key = 0;
+					klient->getNachrichtEncrypted((char*)&gruppeId, 4);
+					klient->getNachrichtEncrypted((char*)&key, 1);
+					char* nachricht = new char[key + 1];
+					nachricht[(int)key] = 0;
+					if (key)
+						klient->getNachrichtEncrypted(nachricht, key);
+					else
+					{
+						klient->sendeEncrypted("\1", 1);
+						delete[] nachricht;
+						break;
+					}
+					klient->sendeEncrypted("\1", 1);
+					Text* message = as->zDB()->getAccountRufName(accountId);
+					message->append(": ");
+					message->append(nachricht);
+					delete[] nachricht;
+					MsgWeiterleitung* weiter = new MsgWeiterleitung(accountId, dynamic_cast<AnmeldungServer*>(as->getThis()));
+					weiter->gruppenNachricht(gruppeId, message->getText());
+					weiter->release();
+					message->release();
+				}
+				break;
+			case 0xE: // spieler anmelden
+				if (1)
+				{
+					if (!klientNummer)
+					{
+						errorZuKlient("Du bist nicht Identifiziert.");
+						break;
+					}
+					klient->sendeEncrypted("\1", 1);
+					int karteId = 0;
+					klient->getNachrichtEncrypted((char*)&karteId, 4);
+					if (!as->zDB()->spielerBesitztKarte(accountId, karteId))
+					{
+						errorZuKlient("Du besitzt entweder die Karte oder das Spiel nicht.");
+						break;
+					}
+					int ret = as->zDB()->accountAnmelden(accountId, karteId);
+					switch (ret)
+					{
+					case 0:
+						errorZuKlient("Du bist nicht eingeloggt.");
+						break;
+					case 1:
+						errorZuKlient("Du wurdest bereits einem Spiel zugeordnet.");
+						break;
+					case 2:
+						errorZuKlient("Du bist in einem anderen noch laufendem Spiel. Spiele es zu Ende.");
+						break;
+					case 3:
+						errorZuKlient("Du bist in einer anderen Gruppe.");
+						break;
+					case 4:
+						errorZuKlient("Du bist bereits in der Warteschlange.");
+						break;
+					case 5:
+						errorZuKlient("Die Karte ist zur Zeit nicht spielbar.");
+						break;
+					case 6:
+						errorZuKlient("Unbekannter Fehler.");
+						break;
+					case 7:
+						klient->sendeEncrypted("\1", 1);
+						break;
+					}
+				}
+				break;
+			case 0xF: // spieler abmelden
+				if (!klientNummer)
+				{
+					errorZuKlient("Du bist nicht Identifiziert.");
+					break;
+				}
+				klient->sendeEncrypted("\1", 1);
+				as->zDB()->accountAbmelden(accountId);
+				break;
+			case 0x10: // gruppe Spiel Starten
+				if (1)
+				{
+					if (!klientNummer)
+					{
+						errorZuKlient("Du bist nicht Identifiziert.");
+						break;
+					}
+					klient->sendeEncrypted("\1", 1);
+					char spielStarten = 0;
+					int gruppeId = 0;
+					klient->getNachrichtEncrypted((char*)&gruppeId, 4);
+					klient->getNachrichtEncrypted(&spielStarten, 1);
+					if (spielStarten && as->zDB()->getSpielerInGruppeAnzahl(gruppeId) < 2)
+					{
+						errorZuKlient("Es müssen sich mindestens 2 Spieler in der Gruppe befinden.");
+						break;
+					}
+					if (as->zDB()->setGruppeSpielStarten(accountId, gruppeId, spielStarten == 1))
+					{
+						klient->sendeEncrypted("\1", 1);
+						MsgWeiterleitung* weiter = new MsgWeiterleitung(accountId, dynamic_cast<AnmeldungServer*>(as->getThis()));
+						weiter->gruppeSpielStarten(gruppeId, spielStarten == 1);
+						weiter->release();
+					}
+					else
+						errorZuKlient("Du kannst diese Option nicht setzen.");
+				}
+				break;
+			case 0x11: // gruppe Einladung abbrechen
+				if (1)
+				{
+					if (!klientNummer)
+					{
+						errorZuKlient("Du bist nicht Identifiziert.");
+						break;
+					}
+					klient->sendeEncrypted("\1", 1);
+					int gruppeId = 0;
+					int accountId = 0;
+					klient->getNachrichtEncrypted((char*)&gruppeId, 4);
+					klient->getNachrichtEncrypted((char*)&accountId, 4);
+					if (as->zDB()->gruppeEinladungAbbrechen(this->accountId, gruppeId, accountId))
+					{
+						klient->sendeEncrypted("\1", 1);
+						MsgWeiterleitung* weiter = new MsgWeiterleitung(accountId, dynamic_cast<AnmeldungServer*>(as->getThis()));
+						weiter->spielEinladungAbbrechen(gruppeId, accountId);
+						weiter->release();
+					}
+					else
+						errorZuKlient("Du kannst diese Option nicht setzen.");
+				}
+				break;
+			case 0x12: // gruppe Einladung ablehnen
+				if (1)
+				{
+					if (!klientNummer)
+					{
+						errorZuKlient("Du bist nicht Identifiziert.");
+						break;
+					}
+					klient->sendeEncrypted("\1", 1);
+					int gruppeId = 0;
+					klient->getNachrichtEncrypted((char*)&gruppeId, 4);
+					klient->sendeEncrypted("\1", 1);
+					as->zDB()->gruppeEinladungAbbrechen(as->zDB()->getGruppeAdminId(gruppeId), gruppeId, accountId);
+					MsgWeiterleitung* weiter = new MsgWeiterleitung(accountId, dynamic_cast<AnmeldungServer*>(as->getThis()));
+					weiter->spielEinladungAblehnen(gruppeId);
+					weiter->release();
+				}
+				break;
+			case 0x13: // ping
+				if (1)
+				{
+					if (!klientNummer)
+					{
+						errorZuKlient("Du bist nicht Identifiziert.");
+						break;
+					}
+					klient->sendeEncrypted("\1", 1);
+				}
+				break;
+			default:
+				errorZuKlient("Unbekannte Nachricht!");
+				break;
+			}
+			if (br)
+				break;
+			as->addEmpfangen(klient->getDownloadBytes(1));
+			as->addGesendet(klient->getUploadBytes(1));
+		}
+	}
+	as->addEmpfangen(klient->getDownloadBytes(1));
+	as->addGesendet(klient->getUploadBytes(1));
+	as->removeKlient(this); // delete this
 }
 
 // constant
-void ASKlient::errorZuKlient( const char *nachricht ) const // sendet eine Fehlernachricht zum Klient
+void ASKlient::errorZuKlient(const char* nachricht) const // sendet eine Fehlernachricht zum Klient
 {
-    klient->sendeEncrypted( "\3", 1 );
-    char key = (char)textLength( nachricht );
-    klient->sendeEncrypted( &key, 1 );
-    klient->sendeEncrypted( nachricht, key );
+	klient->sendeEncrypted("\3", 1);
+	char key = (char)textLength(nachricht);
+	klient->sendeEncrypted(&key, 1);
+	klient->sendeEncrypted(nachricht, key);
 }
 
 int ASKlient::getKlientNummer() const // gibt die KlientId zurück
 {
-    return klientNummer;
+	return klientNummer;
 }
 
 // Inhalt der MsgWeiterleitung Klasse aus AnmeldungServer.h
 // Konstruktor
-MsgWeiterleitung::MsgWeiterleitung( int accountId, AnmeldungServer *as )
-    : ReferenceCounter()
+MsgWeiterleitung::MsgWeiterleitung(int accountId, AnmeldungServer* as)
+	: ReferenceCounter()
 {
-    fehler = new Text( "" );
-    this->accountId = accountId;
-    this->as = as;
+	fehler = new Text("");
+	this->accountId = accountId;
+	this->as = as;
 }
 
 // Destruktor
 MsgWeiterleitung::~MsgWeiterleitung()
 {
-    fehler->release();
-    as->release();
+	fehler->release();
+	as->release();
 }
 
 // nicht constant
-bool MsgWeiterleitung::spielerBetrittGruppe( int gruppeId )
+bool MsgWeiterleitung::spielerBetrittGruppe(int gruppeId)
 {
-    bool ret = 1;
-    Array< int > *accId = new Array< int >();
-    int anzahl = 0;
-    as->zDB()->getSpielerInGruppe( gruppeId, accId, &anzahl );
-    for( int i = 0; i < anzahl; i++ )
-    {
-        int account = accId->get( i );
-        if( account == accountId )
-            continue;
-        Text *ip = new Text( "" );
-        int port = 0;
-        ret = ret & as->zDB()->getChatServer( account, ip, &port );
-        if( ip->istGleich( as->getIp() ) )
-            ip->setText( "127.0.0.1" );
-        if( ip->getLength() )
-        {
-            Klient *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( (unsigned short)port, ip->getText() );
-            ret = ret & klient->sendeEncrypted( "\5\x14", 2 );
-            char res = 0;
-            ret = ret & klient->getNachrichtEncrypted( &res, 1 );
-            if( res )
-            {
-                ret = ret & klient->sendeEncrypted( (char *)&account, 4 );
-                ret = ret & klient->sendeEncrypted( (char *)&accountId, 4 );
-                ret = ret & klient->sendeEncrypted( (char *)&gruppeId, 4 );
-                ret = ret & klient->getNachrichtEncrypted( &res, 1 );
-            }
-            ret = (char)ret & res;
-            as->addEmpfangen( klient->getDownloadBytes( 1 ) );
-            as->addGesendet( klient->getUploadBytes( 1 ) );
-            klient->trenne();
-            klient = (Klient *)klient->release();
-        }
-        ip->release();
-    }
-    accId->release();
-    if( !ret )
-        fehler->setText( "Einer oder mehr Accounts konnen nicht erreicht werden" );
-    return ret;
+	bool ret = 1;
+	Array< int >* accId = new Array< int >();
+	int anzahl = 0;
+	as->zDB()->getSpielerInGruppe(gruppeId, accId, &anzahl);
+	for (int i = 0; i < anzahl; i++)
+	{
+		int account = accId->get(i);
+		if (account == accountId)
+			continue;
+		Text* ip = new Text("");
+		int port = 0;
+		ret = ret & as->zDB()->getChatServer(account, ip, &port);
+		if (ip->istGleich(as->getIp()))
+			ip->setText("127.0.0.1");
+		if (ip->getLength())
+		{
+			Klient* 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((unsigned short)port, ip->getText());
+			ret = ret & klient->sendeEncrypted("\5\x14", 2);
+			char res = 0;
+			ret = ret & klient->getNachrichtEncrypted(&res, 1);
+			if (res)
+			{
+				ret = ret & klient->sendeEncrypted((char*)&account, 4);
+				ret = ret & klient->sendeEncrypted((char*)&accountId, 4);
+				ret = ret & klient->sendeEncrypted((char*)&gruppeId, 4);
+				ret = ret & klient->getNachrichtEncrypted(&res, 1);
+			}
+			ret = (char)ret & res;
+			as->addEmpfangen(klient->getDownloadBytes(1));
+			as->addGesendet(klient->getUploadBytes(1));
+			klient->trenne();
+			klient = (Klient*)klient->release();
+		}
+		ip->release();
+	}
+	accId->release();
+	if (!ret)
+		fehler->setText("Einer oder mehr Accounts konnen nicht erreicht werden");
+	return ret;
 }
 
-bool MsgWeiterleitung::spielerLeavesGruppe( int gruppeId )
+bool MsgWeiterleitung::spielerLeavesGruppe(int gruppeId)
 {
-    bool ret = 1;
-    Array< int > *accId = new Array< int >();
-    int anzahl = 0;
-    as->zDB()->getSpielerInGruppe( gruppeId, accId, &anzahl );
-    for( int i = 0; i < anzahl; i++ )
-    {
-        int account = accId->get( i );
-        if( account == accountId )
-            continue;
-        Text *ip = new Text( "" );
-        int port = 0;
-        ret = ret & as->zDB()->getChatServer( account, ip, &port );
-        if( ip->istGleich( as->getIp() ) )
-            ip->setText( "127.0.0.1" );
-        if( ip->getLength() )
-        {
-            Klient *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( (unsigned short)port, ip->getText() );
-            ret = ret & klient->sendeEncrypted( "\5\x15", 2 );
-            char res = 0;
-            ret = ret & klient->getNachrichtEncrypted( &res, 1 );
-            if( res )
-            {
-                ret = ret & klient->sendeEncrypted( (char *)&account, 4 );
-                ret = ret & klient->sendeEncrypted( (char *)&accountId, 4 );
-                ret = ret & klient->sendeEncrypted( (char *)&gruppeId, 4 );
-                ret = ret & klient->getNachrichtEncrypted( &res, 1 );
-            }
-            ret = (char)ret & res;
-            as->addEmpfangen( klient->getDownloadBytes( 1 ) );
-            as->addGesendet( klient->getUploadBytes( 1 ) );
-            klient->trenne();
-            klient = (Klient *)klient->release();
-        }
-        ip->release();
-    }
-    accId->release();
-    if( !ret )
-        fehler->setText( "Einer oder mehr Accounts konnen nicht erreicht werden" );
-    return ret;
+	bool ret = 1;
+	Array< int >* accId = new Array< int >();
+	int anzahl = 0;
+	as->zDB()->getSpielerInGruppe(gruppeId, accId, &anzahl);
+	for (int i = 0; i < anzahl; i++)
+	{
+		int account = accId->get(i);
+		if (account == accountId)
+			continue;
+		Text* ip = new Text("");
+		int port = 0;
+		ret = ret & as->zDB()->getChatServer(account, ip, &port);
+		if (ip->istGleich(as->getIp()))
+			ip->setText("127.0.0.1");
+		if (ip->getLength())
+		{
+			Klient* 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((unsigned short)port, ip->getText());
+			ret = ret & klient->sendeEncrypted("\5\x15", 2);
+			char res = 0;
+			ret = ret & klient->getNachrichtEncrypted(&res, 1);
+			if (res)
+			{
+				ret = ret & klient->sendeEncrypted((char*)&account, 4);
+				ret = ret & klient->sendeEncrypted((char*)&accountId, 4);
+				ret = ret & klient->sendeEncrypted((char*)&gruppeId, 4);
+				ret = ret & klient->getNachrichtEncrypted(&res, 1);
+			}
+			ret = (char)ret & res;
+			as->addEmpfangen(klient->getDownloadBytes(1));
+			as->addGesendet(klient->getUploadBytes(1));
+			klient->trenne();
+			klient = (Klient*)klient->release();
+		}
+		ip->release();
+	}
+	accId->release();
+	if (!ret)
+		fehler->setText("Einer oder mehr Accounts konnen nicht erreicht werden");
+	return ret;
 }
 
-bool MsgWeiterleitung::setGruppeAdmin( int gruppeId, int admin )
+bool MsgWeiterleitung::setGruppeAdmin(int gruppeId, int admin)
 {
-    bool ret = 1;
-    Array< int > *accId = new Array< int >();
-    int anzahl = 0;
-    as->zDB()->getSpielerInGruppe( gruppeId, accId, &anzahl );
-    for( int i = 0; i < anzahl; i++ )
-    {
-        int account = accId->get( i );
-        if( account == accountId )
-            continue;
-        Text *ip = new Text( "" );
-        int port = 0;
-        ret = ret & as->zDB()->getChatServer( account, ip, &port );
-        if( ip->istGleich( as->getIp() ) )
-            ip->setText( "127.0.0.1" );
-        if( ip->getLength() )
-        {
-            Klient *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( (unsigned short)port, ip->getText() );
-            ret = ret & klient->sendeEncrypted( "\5\x1B", 2 );
-            char res = 0;
-            ret = ret & klient->getNachrichtEncrypted( &res, 1 );
-            if( res )
-            {
-                ret = ret & klient->sendeEncrypted( (char *)&account, 4 );
-                ret = ret & klient->sendeEncrypted( (char *)&admin, 4 );
-                ret = ret & klient->sendeEncrypted( (char *)&gruppeId, 4 );
-                ret = ret & klient->getNachrichtEncrypted( &res, 1 );
-            }
-            ret = (char)ret & res;
-            as->addEmpfangen( klient->getDownloadBytes( 1 ) );
-            as->addGesendet( klient->getUploadBytes( 1 ) );
-            klient->trenne();
-            klient = (Klient *)klient->release();
-        }
-        ip->release();
-    }
-    accId->release();
-    if( !ret )
-        fehler->setText( "Einer oder mehr Accounts konnen nicht erreicht werden" );
-    return ret;
+	bool ret = 1;
+	Array< int >* accId = new Array< int >();
+	int anzahl = 0;
+	as->zDB()->getSpielerInGruppe(gruppeId, accId, &anzahl);
+	for (int i = 0; i < anzahl; i++)
+	{
+		int account = accId->get(i);
+		if (account == accountId)
+			continue;
+		Text* ip = new Text("");
+		int port = 0;
+		ret = ret & as->zDB()->getChatServer(account, ip, &port);
+		if (ip->istGleich(as->getIp()))
+			ip->setText("127.0.0.1");
+		if (ip->getLength())
+		{
+			Klient* 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((unsigned short)port, ip->getText());
+			ret = ret & klient->sendeEncrypted("\5\x1B", 2);
+			char res = 0;
+			ret = ret & klient->getNachrichtEncrypted(&res, 1);
+			if (res)
+			{
+				ret = ret & klient->sendeEncrypted((char*)&account, 4);
+				ret = ret & klient->sendeEncrypted((char*)&admin, 4);
+				ret = ret & klient->sendeEncrypted((char*)&gruppeId, 4);
+				ret = ret & klient->getNachrichtEncrypted(&res, 1);
+			}
+			ret = (char)ret & res;
+			as->addEmpfangen(klient->getDownloadBytes(1));
+			as->addGesendet(klient->getUploadBytes(1));
+			klient->trenne();
+			klient = (Klient*)klient->release();
+		}
+		ip->release();
+	}
+	accId->release();
+	if (!ret)
+		fehler->setText("Einer oder mehr Accounts konnen nicht erreicht werden");
+	return ret;
 }
 
-bool MsgWeiterleitung::kickSpielerAusGruppe( int accountId, int gruppeId )
+bool MsgWeiterleitung::kickSpielerAusGruppe(int accountId, int gruppeId)
 {
-    bool ret = 1;
-    Text *ip = new Text( "" );
-    int port = 0;
-    ret = ret & as->zDB()->getChatServer( accountId, ip, &port );
-    if( ip->istGleich( as->getIp() ) )
-        ip->setText( "127.0.0.1" );
-    if( ip->getLength() )
-    {
-        Klient *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( (unsigned short)port, ip->getText() );
-        ret = ret & klient->sendeEncrypted( "\5\x16", 2 );
-        char res = 0;
-        ret = ret & klient->getNachrichtEncrypted( &res, 1 );
-        if( res )
-        {
-            ret = ret & klient->sendeEncrypted( (char *)&accountId, 4 );
-            ret = ret & klient->sendeEncrypted( (char *)&gruppeId, 4 );
-            ret = ret & klient->getNachrichtEncrypted( &res, 1 );
-        }
-        ret = (char)ret & res;
-        as->addEmpfangen( klient->getDownloadBytes( 1 ) );
-        as->addGesendet( klient->getUploadBytes( 1 ) );
-        klient->trenne();
-        klient = (Klient *)klient->release();
-    }
-    ip->release();
-    if( !ret )
-        fehler->setText( "Einer oder mehr Accounts konnen nicht erreicht werden" );
-    return ret;
+	bool ret = 1;
+	Text* ip = new Text("");
+	int port = 0;
+	ret = ret & as->zDB()->getChatServer(accountId, ip, &port);
+	if (ip->istGleich(as->getIp()))
+		ip->setText("127.0.0.1");
+	if (ip->getLength())
+	{
+		Klient* 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((unsigned short)port, ip->getText());
+		ret = ret & klient->sendeEncrypted("\5\x16", 2);
+		char res = 0;
+		ret = ret & klient->getNachrichtEncrypted(&res, 1);
+		if (res)
+		{
+			ret = ret & klient->sendeEncrypted((char*)&accountId, 4);
+			ret = ret & klient->sendeEncrypted((char*)&gruppeId, 4);
+			ret = ret & klient->getNachrichtEncrypted(&res, 1);
+		}
+		ret = (char)ret & res;
+		as->addEmpfangen(klient->getDownloadBytes(1));
+		as->addGesendet(klient->getUploadBytes(1));
+		klient->trenne();
+		klient = (Klient*)klient->release();
+	}
+	ip->release();
+	if (!ret)
+		fehler->setText("Einer oder mehr Accounts konnen nicht erreicht werden");
+	return ret;
 }
 
-bool MsgWeiterleitung::gruppenNachricht( int gruppeId, char *txt )
+bool MsgWeiterleitung::gruppenNachricht(int gruppeId, const char* txt)
 {
-    bool ret = 1;
-    char len = (char)textLength( txt );
-    if( !len )
-        return 0;
-    Array< int > *accId = new Array< int >();
-    int anzahl = 0;
-    as->zDB()->getSpielerInGruppe( gruppeId, accId, &anzahl );
-    for( int i = 0; i < anzahl; i++ )
-    {
-        int account = accId->get( i );
-        Text *ip = new Text( "" );
-        int port = 0;
-        ret = ret & as->zDB()->getChatServer( account, ip, &port );
-        if( ip->istGleich( as->getIp() ) )
-            ip->setText( "127.0.0.1" );
-        if( ip->getLength() )
-        {
-            Klient *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( (unsigned short)port, ip->getText() );
-            ret = ret & klient->sendeEncrypted( "\5\x19", 2 );
-            char res = 0;
-            ret = ret & klient->getNachrichtEncrypted( &res, 1 );
-            if( res )
-            {
-                ret = ret & klient->sendeEncrypted( (char *)&account, 4 );
-                ret = ret & klient->sendeEncrypted( (char *)&gruppeId, 4 );
-                ret = ret & klient->sendeEncrypted( (char *)&len, 1 );
-                if( len )
-                    ret = ret & klient->sendeEncrypted( txt, len );
-                ret = ret & klient->getNachrichtEncrypted( &res, 1 );
-            }
-            ret = (char)ret & res;
-            as->addEmpfangen( klient->getDownloadBytes( 1 ) );
-            as->addGesendet( klient->getUploadBytes( 1 ) );
-            klient->trenne();
-            klient = (Klient *)klient->release();
-        }
-        ip->release();
-    }
-    accId->release();
-    if( !ret )
-        fehler->setText( "Einer oder mehr Accounts konnen nicht erreicht werden" );
-    return ret;
+	bool ret = 1;
+	char len = (char)textLength(txt);
+	if (!len)
+		return 0;
+	Array< int >* accId = new Array< int >();
+	int anzahl = 0;
+	as->zDB()->getSpielerInGruppe(gruppeId, accId, &anzahl);
+	for (int i = 0; i < anzahl; i++)
+	{
+		int account = accId->get(i);
+		Text* ip = new Text("");
+		int port = 0;
+		ret = ret & as->zDB()->getChatServer(account, ip, &port);
+		if (ip->istGleich(as->getIp()))
+			ip->setText("127.0.0.1");
+		if (ip->getLength())
+		{
+			Klient* 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((unsigned short)port, ip->getText());
+			ret = ret & klient->sendeEncrypted("\5\x19", 2);
+			char res = 0;
+			ret = ret & klient->getNachrichtEncrypted(&res, 1);
+			if (res)
+			{
+				ret = ret & klient->sendeEncrypted((char*)&account, 4);
+				ret = ret & klient->sendeEncrypted((char*)&gruppeId, 4);
+				ret = ret & klient->sendeEncrypted((char*)&len, 1);
+				if (len)
+					ret = ret & klient->sendeEncrypted(txt, len);
+				ret = ret & klient->getNachrichtEncrypted(&res, 1);
+			}
+			ret = (char)ret & res;
+			as->addEmpfangen(klient->getDownloadBytes(1));
+			as->addGesendet(klient->getUploadBytes(1));
+			klient->trenne();
+			klient = (Klient*)klient->release();
+		}
+		ip->release();
+	}
+	accId->release();
+	if (!ret)
+		fehler->setText("Einer oder mehr Accounts konnen nicht erreicht werden");
+	return ret;
 }
 
-bool MsgWeiterleitung::gruppeAngemeldet( int gruppeId )
+bool MsgWeiterleitung::gruppeAngemeldet(int gruppeId)
 {
-    bool ret = 1;
-    Array< int > *accId = new Array< int >();
-    int anzahl = 0;
-    as->zDB()->getSpielerInGruppe( gruppeId, accId, &anzahl );
-    for( int i = 0; i < anzahl; i++ )
-    {
-        int account = accId->get( i );
-        Text *ip = new Text( "" );
-        int port = 0;
-        ret = ret & as->zDB()->getChatServer( account, ip, &port );
-        if( ip->istGleich( as->getIp() ) )
-            ip->setText( "127.0.0.1" );
-        if( ip->getLength() )
-        {
-            Klient *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( (unsigned short)port, ip->getText() );
-            ret = ret & klient->sendeEncrypted( "\5\x17", 2 );
-            char res = 0;
-            ret = ret & klient->getNachrichtEncrypted( &res, 1 );
-            if( res )
-            {
-                ret = ret & klient->sendeEncrypted( (char *)&account, 4 );
-                ret = ret & klient->sendeEncrypted( (char *)&gruppeId, 4 );
-                ret = ret & klient->getNachrichtEncrypted( &res, 1 );
-            }
-            ret = (char)ret & res;
-            as->addEmpfangen( klient->getDownloadBytes( 1 ) );
-            as->addGesendet( klient->getUploadBytes( 1 ) );
-            klient->trenne();
-            klient = (Klient *)klient->release();
-        }
-        ip->release();
-    }
-    accId->release();
-    if( !ret )
-        fehler->setText( "Einer oder mehr Accounts konnen nicht erreicht werden" );
-    return ret;
+	bool ret = 1;
+	Array< int >* accId = new Array< int >();
+	int anzahl = 0;
+	as->zDB()->getSpielerInGruppe(gruppeId, accId, &anzahl);
+	for (int i = 0; i < anzahl; i++)
+	{
+		int account = accId->get(i);
+		Text* ip = new Text("");
+		int port = 0;
+		ret = ret & as->zDB()->getChatServer(account, ip, &port);
+		if (ip->istGleich(as->getIp()))
+			ip->setText("127.0.0.1");
+		if (ip->getLength())
+		{
+			Klient* 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((unsigned short)port, ip->getText());
+			ret = ret & klient->sendeEncrypted("\5\x17", 2);
+			char res = 0;
+			ret = ret & klient->getNachrichtEncrypted(&res, 1);
+			if (res)
+			{
+				ret = ret & klient->sendeEncrypted((char*)&account, 4);
+				ret = ret & klient->sendeEncrypted((char*)&gruppeId, 4);
+				ret = ret & klient->getNachrichtEncrypted(&res, 1);
+			}
+			ret = (char)ret & res;
+			as->addEmpfangen(klient->getDownloadBytes(1));
+			as->addGesendet(klient->getUploadBytes(1));
+			klient->trenne();
+			klient = (Klient*)klient->release();
+		}
+		ip->release();
+	}
+	accId->release();
+	if (!ret)
+		fehler->setText("Einer oder mehr Accounts konnen nicht erreicht werden");
+	return ret;
 }
 
-bool MsgWeiterleitung::gruppeAbgemeldet( int gruppeId )
+bool MsgWeiterleitung::gruppeAbgemeldet(int gruppeId)
 {
-    bool ret = 1;
-    Array< int > *accId = new Array< int >();
-    int anzahl = 0;
-    as->zDB()->getSpielerInGruppe( gruppeId, accId, &anzahl );
-    for( int i = 0; i < anzahl; i++ )
-    {
-        int account = accId->get( i );
-        Text *ip = new Text( "" );
-        int port = 0;
-        ret = ret & as->zDB()->getChatServer( account, ip, &port );
-        if( ip->istGleich( as->getIp() ) )
-            ip->setText( "127.0.0.1" );
-        if( ip->getLength() )
-        {
-            Klient *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( (unsigned short)port, ip->getText() );
-            ret = ret & klient->sendeEncrypted( "\5\x18", 2 );
-            char res = 0;
-            ret = ret & klient->getNachrichtEncrypted( &res, 1 );
-            if( res )
-            {
-                ret = ret & klient->sendeEncrypted( (char *)&account, 4 );
-                ret = ret & klient->sendeEncrypted( (char *)&gruppeId, 4 );
-                ret = ret & klient->getNachrichtEncrypted( &res, 1 );
-            }
-            ret = (char)ret & res;
-            as->addEmpfangen( klient->getDownloadBytes( 1 ) );
-            as->addGesendet( klient->getUploadBytes( 1 ) );
-            klient->trenne();
-            klient = (Klient *)klient->release();
-        }
-        ip->release();
-    }
-    accId->release();
-    if( !ret )
-        fehler->setText( "Einer oder mehr Accounts konnen nicht erreicht werden" );
-    return ret;
+	bool ret = 1;
+	Array< int >* accId = new Array< int >();
+	int anzahl = 0;
+	as->zDB()->getSpielerInGruppe(gruppeId, accId, &anzahl);
+	for (int i = 0; i < anzahl; i++)
+	{
+		int account = accId->get(i);
+		Text* ip = new Text("");
+		int port = 0;
+		ret = ret & as->zDB()->getChatServer(account, ip, &port);
+		if (ip->istGleich(as->getIp()))
+			ip->setText("127.0.0.1");
+		if (ip->getLength())
+		{
+			Klient* 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((unsigned short)port, ip->getText());
+			ret = ret & klient->sendeEncrypted("\5\x18", 2);
+			char res = 0;
+			ret = ret & klient->getNachrichtEncrypted(&res, 1);
+			if (res)
+			{
+				ret = ret & klient->sendeEncrypted((char*)&account, 4);
+				ret = ret & klient->sendeEncrypted((char*)&gruppeId, 4);
+				ret = ret & klient->getNachrichtEncrypted(&res, 1);
+			}
+			ret = (char)ret & res;
+			as->addEmpfangen(klient->getDownloadBytes(1));
+			as->addGesendet(klient->getUploadBytes(1));
+			klient->trenne();
+			klient = (Klient*)klient->release();
+		}
+		ip->release();
+	}
+	accId->release();
+	if (!ret)
+		fehler->setText("Einer oder mehr Accounts konnen nicht erreicht werden");
+	return ret;
 }
 
-bool MsgWeiterleitung::gruppeSpielStarten( int gruppeId, bool starten )
+bool MsgWeiterleitung::gruppeSpielStarten(int gruppeId, bool starten)
 {
-    bool ret = 1;
-    Array< int > *accId = new Array< int >();
-    int anzahl = 0;
-    as->zDB()->getSpielerInGruppe( gruppeId, accId, &anzahl );
-    for( int i = 0; i < anzahl; i++ )
-    {
-        int account = accId->get( i );
-        Text *ip = new Text( "" );
-        int port = 0;
-        ret = ret & as->zDB()->getChatServer( account, ip, &port );
-        if( ip->istGleich( as->getIp() ) )
-            ip->setText( "127.0.0.1" );
-        if( ip->getLength() )
-        {
-            Klient *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( (unsigned short)port, ip->getText() );
-            ret = ret & klient->sendeEncrypted( "\5\x1A", 2 );
-            char res = 0;
-            ret = ret & klient->getNachrichtEncrypted( &res, 1 );
-            if( res )
-            {
-                ret = ret & klient->sendeEncrypted( (char *)&account, 4 );
-                ret = ret & klient->sendeEncrypted( (char *)&gruppeId, 4 );
-                ret = ret & klient->sendeEncrypted( (char *)&starten, 1 );
-                ret = ret & klient->getNachrichtEncrypted( &res, 1 );
-            }
-            ret = (char)ret & res;
-            as->addEmpfangen( klient->getDownloadBytes( 1 ) );
-            as->addGesendet( klient->getUploadBytes( 1 ) );
-            klient->trenne();
-            klient = (Klient *)klient->release();
-        }
-        ip->release();
-    }
-    accId->release();
-    if( !ret )
-        fehler->setText( "Einer oder mehr Accounts konnen nicht erreicht werden" );
-    return ret;
+	bool ret = 1;
+	Array< int >* accId = new Array< int >();
+	int anzahl = 0;
+	as->zDB()->getSpielerInGruppe(gruppeId, accId, &anzahl);
+	for (int i = 0; i < anzahl; i++)
+	{
+		int account = accId->get(i);
+		Text* ip = new Text("");
+		int port = 0;
+		ret = ret & as->zDB()->getChatServer(account, ip, &port);
+		if (ip->istGleich(as->getIp()))
+			ip->setText("127.0.0.1");
+		if (ip->getLength())
+		{
+			Klient* 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((unsigned short)port, ip->getText());
+			ret = ret & klient->sendeEncrypted("\5\x1A", 2);
+			char res = 0;
+			ret = ret & klient->getNachrichtEncrypted(&res, 1);
+			if (res)
+			{
+				ret = ret & klient->sendeEncrypted((char*)&account, 4);
+				ret = ret & klient->sendeEncrypted((char*)&gruppeId, 4);
+				ret = ret & klient->sendeEncrypted((char*)&starten, 1);
+				ret = ret & klient->getNachrichtEncrypted(&res, 1);
+			}
+			ret = (char)ret & res;
+			as->addEmpfangen(klient->getDownloadBytes(1));
+			as->addGesendet(klient->getUploadBytes(1));
+			klient->trenne();
+			klient = (Klient*)klient->release();
+		}
+		ip->release();
+	}
+	accId->release();
+	if (!ret)
+		fehler->setText("Einer oder mehr Accounts konnen nicht erreicht werden");
+	return ret;
 }
 
-bool MsgWeiterleitung::spielEinladung( int gruppeId, int accountId )
+bool MsgWeiterleitung::spielEinladung(int gruppeId, int accountId)
 {
-    // Einladung zum spieler Senden
-    bool ret = 1;
-    Text *ip = new Text( "" );
-    int port = 0;
-    ret = ret & as->zDB()->getChatServer( accountId, ip, &port );
-    if( ip->istGleich( as->getIp() ) )
-        ip->setText( "127.0.0.1" );
-    if( ip->getLength() )
-    {
-        Klient *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( (unsigned short)port, ip->getText() );
-        ret = ret & klient->sendeEncrypted( "\5\5", 2 );
-        char res = 0;
-        ret = ret & klient->getNachrichtEncrypted( &res, 1 );
-        if( res )
-        {
-            ret = ret & klient->sendeEncrypted( (char *)&accountId, 4 );
-            ret = ret & klient->sendeEncrypted( (char *)&this->accountId, 4 );
-            ret = ret & klient->sendeEncrypted( (char *)&gruppeId, 4 );
-            ret = ret & klient->getNachrichtEncrypted( &res, 1 );
-        }
-        ret = (char)ret & res;
-        as->addEmpfangen( klient->getDownloadBytes( 1 ) );
-        as->addGesendet( klient->getUploadBytes( 1 ) );
-        klient->trenne();
-        klient = (Klient *)klient->release();
-    }
-    ip->release();
-    // Einladung zu den Gruppenmitgliedern senden
-    Array< int > *accId = new Array< int >();
-    int anzahl = 0;
-    as->zDB()->getSpielerInGruppe( gruppeId, accId, &anzahl );
-    for( int i = 0; i < anzahl; i++ )
-    {
-        int account = accId->get( i );
-        Text *ip = new Text( "" );
-        int port = 0;
-        ret = ret & as->zDB()->getChatServer( account, ip, &port );
-        if( ip->istGleich( as->getIp() ) )
-            ip->setText( "127.0.0.1" );
-        if( ip->getLength() )
-        {
-            Klient *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( (unsigned short)port, ip->getText() );
-            ret = ret & klient->sendeEncrypted( "\5\x1F", 2 );
-            char res = 0;
-            ret = ret & klient->getNachrichtEncrypted( &res, 1 );
-            if( res )
-            {
-                ret = ret & klient->sendeEncrypted( (char *)&account, 4 );
-                ret = ret & klient->sendeEncrypted( (char *)&gruppeId, 4 );
-                ret = ret & klient->sendeEncrypted( (char *)&accountId, 4 );
-                ret = ret & klient->getNachrichtEncrypted( &res, 1 );
-            }
-            ret = (char)ret & res;
-            as->addEmpfangen( klient->getDownloadBytes( 1 ) );
-            as->addGesendet( klient->getUploadBytes( 1 ) );
-            klient->trenne();
-            klient = (Klient *)klient->release();
-        }
-        ip->release();
-    }
-    accId->release();
-    if( !ret )
-        fehler->setText( "Einer oder mehr Accounts konnen nicht erreicht werden" );
-    return ret;
+	// Einladung zum spieler Senden
+	bool ret = 1;
+	Text* ip = new Text("");
+	int port = 0;
+	ret = ret & as->zDB()->getChatServer(accountId, ip, &port);
+	if (ip->istGleich(as->getIp()))
+		ip->setText("127.0.0.1");
+	if (ip->getLength())
+	{
+		Klient* 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((unsigned short)port, ip->getText());
+		ret = ret & klient->sendeEncrypted("\5\5", 2);
+		char res = 0;
+		ret = ret & klient->getNachrichtEncrypted(&res, 1);
+		if (res)
+		{
+			ret = ret & klient->sendeEncrypted((char*)&accountId, 4);
+			ret = ret & klient->sendeEncrypted((char*)&this->accountId, 4);
+			ret = ret & klient->sendeEncrypted((char*)&gruppeId, 4);
+			ret = ret & klient->getNachrichtEncrypted(&res, 1);
+		}
+		ret = (char)ret & res;
+		as->addEmpfangen(klient->getDownloadBytes(1));
+		as->addGesendet(klient->getUploadBytes(1));
+		klient->trenne();
+		klient = (Klient*)klient->release();
+	}
+	ip->release();
+	// Einladung zu den Gruppenmitgliedern senden
+	Array< int >* accId = new Array< int >();
+	int anzahl = 0;
+	as->zDB()->getSpielerInGruppe(gruppeId, accId, &anzahl);
+	for (int i = 0; i < anzahl; i++)
+	{
+		int account = accId->get(i);
+		Text* ip = new Text("");
+		int port = 0;
+		ret = ret & as->zDB()->getChatServer(account, ip, &port);
+		if (ip->istGleich(as->getIp()))
+			ip->setText("127.0.0.1");
+		if (ip->getLength())
+		{
+			Klient* 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((unsigned short)port, ip->getText());
+			ret = ret & klient->sendeEncrypted("\5\x1F", 2);
+			char res = 0;
+			ret = ret & klient->getNachrichtEncrypted(&res, 1);
+			if (res)
+			{
+				ret = ret & klient->sendeEncrypted((char*)&account, 4);
+				ret = ret & klient->sendeEncrypted((char*)&gruppeId, 4);
+				ret = ret & klient->sendeEncrypted((char*)&accountId, 4);
+				ret = ret & klient->getNachrichtEncrypted(&res, 1);
+			}
+			ret = (char)ret & res;
+			as->addEmpfangen(klient->getDownloadBytes(1));
+			as->addGesendet(klient->getUploadBytes(1));
+			klient->trenne();
+			klient = (Klient*)klient->release();
+		}
+		ip->release();
+	}
+	accId->release();
+	if (!ret)
+		fehler->setText("Einer oder mehr Accounts konnen nicht erreicht werden");
+	return ret;
 }
 
-bool MsgWeiterleitung::spielEinladungAbbrechen( int gruppeId, int accountId )
+bool MsgWeiterleitung::spielEinladungAbbrechen(int gruppeId, int accountId)
 {
-    bool ret = 1;
-    Array< int > *accId = new Array< int >();
-    int anzahl = 0;
-    as->zDB()->getSpielerInGruppe( gruppeId, accId, &anzahl );
-    for( int i = 0; i < anzahl; i++ )
-    {
-        int account = accId->get( i );
-        Text *ip = new Text( "" );
-        int port = 0;
-        ret = ret & as->zDB()->getChatServer( account, ip, &port );
-        if( ip->istGleich( as->getIp() ) )
-            ip->setText( "127.0.0.1" );
-        if( ip->getLength() )
-        {
-            Klient *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( (unsigned short)port, ip->getText() );
-            ret = ret & klient->sendeEncrypted( "\5\x1E", 2 );
-            char res = 0;
-            ret = ret & klient->getNachrichtEncrypted( &res, 1 );
-            if( res )
-            {
-                ret = ret & klient->sendeEncrypted( (char *)&account, 4 );
-                ret = ret & klient->sendeEncrypted( (char *)&gruppeId, 4 );
-                ret = ret & klient->sendeEncrypted( (char *)&accountId, 4 );
-                ret = ret & klient->getNachrichtEncrypted( &res, 1 );
-            }
-            ret = (char)ret & res;
-            as->addEmpfangen( klient->getDownloadBytes( 1 ) );
-            as->addGesendet( klient->getUploadBytes( 1 ) );
-            klient->trenne();
-            klient = (Klient *)klient->release();
-        }
-        ip->release();
-    }
-    accId->release();
-    if( !ret )
-        fehler->setText( "Einer oder mehr Accounts konnen nicht erreicht werden" );
-    return ret;
+	bool ret = 1;
+	Array< int >* accId = new Array< int >();
+	int anzahl = 0;
+	as->zDB()->getSpielerInGruppe(gruppeId, accId, &anzahl);
+	for (int i = 0; i < anzahl; i++)
+	{
+		int account = accId->get(i);
+		Text* ip = new Text("");
+		int port = 0;
+		ret = ret & as->zDB()->getChatServer(account, ip, &port);
+		if (ip->istGleich(as->getIp()))
+			ip->setText("127.0.0.1");
+		if (ip->getLength())
+		{
+			Klient* 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((unsigned short)port, ip->getText());
+			ret = ret & klient->sendeEncrypted("\5\x1E", 2);
+			char res = 0;
+			ret = ret & klient->getNachrichtEncrypted(&res, 1);
+			if (res)
+			{
+				ret = ret & klient->sendeEncrypted((char*)&account, 4);
+				ret = ret & klient->sendeEncrypted((char*)&gruppeId, 4);
+				ret = ret & klient->sendeEncrypted((char*)&accountId, 4);
+				ret = ret & klient->getNachrichtEncrypted(&res, 1);
+			}
+			ret = (char)ret & res;
+			as->addEmpfangen(klient->getDownloadBytes(1));
+			as->addGesendet(klient->getUploadBytes(1));
+			klient->trenne();
+			klient = (Klient*)klient->release();
+		}
+		ip->release();
+	}
+	accId->release();
+	if (!ret)
+		fehler->setText("Einer oder mehr Accounts konnen nicht erreicht werden");
+	return ret;
 }
 
-bool MsgWeiterleitung::spielEinladungAblehnen( int gruppeId )
+bool MsgWeiterleitung::spielEinladungAblehnen(int gruppeId)
 {
-    bool ret = 1;
-    Array< int > *accId = new Array< int >();
-    int anzahl = 0;
-    as->zDB()->getSpielerInGruppe( gruppeId, accId, &anzahl );
-    for( int i = 0; i < anzahl; i++ )
-    {
-        int account = accId->get( i );
-        Text *ip = new Text( "" );
-        int port = 0;
-        ret = ret & as->zDB()->getChatServer( account, ip, &port );
-        if( ip->istGleich( as->getIp() ) )
-            ip->setText( "127.0.0.1" );
-        if( ip->getLength() )
-        {
-            Klient *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( (unsigned short)port, ip->getText() );
-            ret = ret & klient->sendeEncrypted( "\5\x1C", 2 );
-            char res = 0;
-            ret = ret & klient->getNachrichtEncrypted( &res, 1 );
-            if( res )
-            {
-                ret = ret & klient->sendeEncrypted( (char *)&account, 4 );
-                ret = ret & klient->sendeEncrypted( (char *)&accountId, 4 );
-                ret = ret & klient->sendeEncrypted( (char *)&gruppeId, 4 );
-                ret = ret & klient->getNachrichtEncrypted( &res, 1 );
-            }
-            ret = (char)ret & res;
-            as->addEmpfangen( klient->getDownloadBytes( 1 ) );
-            as->addGesendet( klient->getUploadBytes( 1 ) );
-            klient->trenne();
-            klient = (Klient *)klient->release();
-        }
-        ip->release();
-    }
-    accId->release();
-    if( !ret )
-        fehler->setText( "Einer oder mehr Accounts konnen nicht erreicht werden" );
-    return ret;
+	bool ret = 1;
+	Array< int >* accId = new Array< int >();
+	int anzahl = 0;
+	as->zDB()->getSpielerInGruppe(gruppeId, accId, &anzahl);
+	for (int i = 0; i < anzahl; i++)
+	{
+		int account = accId->get(i);
+		Text* ip = new Text("");
+		int port = 0;
+		ret = ret & as->zDB()->getChatServer(account, ip, &port);
+		if (ip->istGleich(as->getIp()))
+			ip->setText("127.0.0.1");
+		if (ip->getLength())
+		{
+			Klient* 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((unsigned short)port, ip->getText());
+			ret = ret & klient->sendeEncrypted("\5\x1C", 2);
+			char res = 0;
+			ret = ret & klient->getNachrichtEncrypted(&res, 1);
+			if (res)
+			{
+				ret = ret & klient->sendeEncrypted((char*)&account, 4);
+				ret = ret & klient->sendeEncrypted((char*)&accountId, 4);
+				ret = ret & klient->sendeEncrypted((char*)&gruppeId, 4);
+				ret = ret & klient->getNachrichtEncrypted(&res, 1);
+			}
+			ret = (char)ret & res;
+			as->addEmpfangen(klient->getDownloadBytes(1));
+			as->addGesendet(klient->getUploadBytes(1));
+			klient->trenne();
+			klient = (Klient*)klient->release();
+		}
+		ip->release();
+	}
+	accId->release();
+	if (!ret)
+		fehler->setText("Einer oder mehr Accounts konnen nicht erreicht werden");
+	return ret;
 }
 
 // constant
 int MsgWeiterleitung::getAccountId() const
 {
-    return accountId;
+	return accountId;
 }
 
-Text *MsgWeiterleitung::getLetzterFehler() const
+Text* MsgWeiterleitung::getLetzterFehler() const
 {
-    return dynamic_cast<Text *>( fehler->getThis() );
+	return dynamic_cast<Text*>(fehler->getThis());
 }
 
-Text *MsgWeiterleitung::zLetzterFehler() const
+Text* MsgWeiterleitung::zLetzterFehler() const
 {
-    return fehler;
+	return fehler;
 }

AnmeldungServer/AnmeldungServer.h

@@ -16,116 +16,116 @@ class ASKlient;
 class AnmeldungServer : public Thread
 {
 private:
-    Server *server;
-    SSLServer *aServer;
-    InitDatei *ini;
-    ASDatenbank *db;
-    CRITICAL_SECTION cs;
-    RCArray< ASKlient > *klients;
-    Text *fehler;
-    int id;
-    bool nichtPausiert;
-    int empfangen;
-    int gesendet;
-    bool end;
+	Server* server;
+	SSLServer* aServer;
+	InitDatei* ini;
+	ASDatenbank* db;
+	CRITICAL_SECTION cs;
+	RCArray< ASKlient >* klients;
+	Text* fehler;
+	int id;
+	bool nichtPausiert;
+	int empfangen;
+	int gesendet;
+	bool end;
 
 public:
-    // Konstruktor 
-    AnmeldungServer( InitDatei *zIni );
-    // Destruktor 
-    virtual ~AnmeldungServer();
-    // nicht constant 
-    void runn();
-    void thread();
-    void close();
-    bool serverStarten();
-    bool serverPause();
-    bool serverFortsetzen();
-    bool serverBeenden();
-    bool setMaxKlients( int mc );
-    bool absturzKlient( int klientId );
-    bool removeKlient( ASKlient *zKlient );
-    void addGesendet( int bytes );
-    void addEmpfangen( int bytes );
-    // conatant 
-    bool istAn() const;
-    Server *zServer() const;
-    ASDatenbank *zDB() const;
-    bool hatClients() const;
-    int getId() const;
-    char *getLetzterFehler() const;
-    char *getIp() const;
+	// Konstruktor 
+	AnmeldungServer(InitDatei* zIni);
+	// Destruktor 
+	virtual ~AnmeldungServer();
+	// nicht constant 
+	void runn();
+	void thread();
+	void close();
+	bool serverStarten();
+	bool serverPause();
+	bool serverFortsetzen();
+	bool serverBeenden();
+	bool setMaxKlients(int mc);
+	bool absturzKlient(int klientId);
+	bool removeKlient(ASKlient* zKlient);
+	void addGesendet(int bytes);
+	void addEmpfangen(int bytes);
+	// conatant 
+	bool istAn() const;
+	Server* zServer() const;
+	ASDatenbank* zDB() const;
+	bool hatClients() const;
+	int getId() const;
+	const char* getLetzterFehler() const;
+	const char* getIp() const;
 };
 
 class ASAKlient : public Thread
 {
 private:
-    SSLSKlient *klient;
-    Text *name;
-    Text *passwort;
-    int adminId;
-    AnmeldungServer *as;
-    int version;
+	SSLSKlient* klient;
+	Text* name;
+	Text* passwort;
+	int adminId;
+	AnmeldungServer* as;
+	int version;
 
 public:
-    // Konstruktor 
-    ASAKlient( SSLSKlient *klient, AnmeldungServer *as );
-    // Destruktor 
-    virtual ~ASAKlient();
-    // nicht constant
-    void thread();
-    void errorZuKlient( const char *nachricht ) const; // sendet eine Fehlernachricht zum AKlient
+	// Konstruktor 
+	ASAKlient(SSLSKlient* klient, AnmeldungServer* as);
+	// Destruktor 
+	virtual ~ASAKlient();
+	// nicht constant
+	void thread();
+	void errorZuKlient(const char* nachricht) const; // sendet eine Fehlernachricht zum AKlient
 };
 
 class ASKlient : public Thread
 {
 private:
-    SKlient *klient;
-    unsigned int klientNummer;
-    AnmeldungServer *as;
-    int accountId;
+	SKlient* klient;
+	unsigned int klientNummer;
+	AnmeldungServer* as;
+	int accountId;
 
 public:
-    // Konstruktor 
-    ASKlient( SKlient *klient, AnmeldungServer *as );
-    // Destruktor 
-    virtual ~ASKlient();
-    // nicht constant
-    void absturz();
-    virtual void thread();
-    // constant
-    void errorZuKlient( const char *nachricht ) const; // sendet eine Fehlernachricht zum Klient
-    int getKlientNummer() const;
+	// Konstruktor 
+	ASKlient(SKlient* klient, AnmeldungServer* as);
+	// Destruktor 
+	virtual ~ASKlient();
+	// nicht constant
+	void absturz();
+	virtual void thread();
+	// constant
+	void errorZuKlient(const char* nachricht) const; // sendet eine Fehlernachricht zum Klient
+	int getKlientNummer() const;
 };
 
 class MsgWeiterleitung : public virtual ReferenceCounter
 {
 private:
-    AnmeldungServer *as;
-    int accountId;
-    Text *fehler;
+	AnmeldungServer* as;
+	int accountId;
+	Text* fehler;
 
 public:
-    // Konstruktor
-    MsgWeiterleitung( int accountId, AnmeldungServer *as );
-    // Destruktor
-    virtual ~MsgWeiterleitung();
-    // nicht constant
-    bool spielerBetrittGruppe( int gruppeId );
-    bool spielerLeavesGruppe( int gruppeId );
-    bool setGruppeAdmin( int gruppeId, int admin );
-    bool kickSpielerAusGruppe( int accountId, int gruppeId );
-    bool gruppenNachricht( int gruppeId, char *txt );
-    bool gruppeAngemeldet( int gruppeId );
-    bool gruppeAbgemeldet( int gruppeId );
-    bool gruppeSpielStarten( int gruppeId, bool starten );
-    bool spielEinladung( int gruppeId, int accountId );
-    bool spielEinladungAbbrechen( int gruppeId, int accountId );
-    bool spielEinladungAblehnen( int gruppeId );
-    // constant
-    int getAccountId() const;
-    Text *getLetzterFehler() const;
-    Text *zLetzterFehler() const;
+	// Konstruktor
+	MsgWeiterleitung(int accountId, AnmeldungServer* as);
+	// Destruktor
+	virtual ~MsgWeiterleitung();
+	// nicht constant
+	bool spielerBetrittGruppe(int gruppeId);
+	bool spielerLeavesGruppe(int gruppeId);
+	bool setGruppeAdmin(int gruppeId, int admin);
+	bool kickSpielerAusGruppe(int accountId, int gruppeId);
+	bool gruppenNachricht(int gruppeId, const char* txt);
+	bool gruppeAngemeldet(int gruppeId);
+	bool gruppeAbgemeldet(int gruppeId);
+	bool gruppeSpielStarten(int gruppeId, bool starten);
+	bool spielEinladung(int gruppeId, int accountId);
+	bool spielEinladungAbbrechen(int gruppeId, int accountId);
+	bool spielEinladungAblehnen(int gruppeId);
+	// constant
+	int getAccountId() const;
+	Text* getLetzterFehler() const;
+	Text* zLetzterFehler() const;
 };
 
 #endif