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

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

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

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

void ChatServer::thread()
{
	while( 1 )
	{
		SKlient *klient;
		klient = server->getKlient();
		if( !klient )
			break;
		Framework::getThreadRegister()->cleanUpClosedThreads();
		CSKlient *clHandle = new CSKlient( klient, getThis() );
		cs.lock();
		klients->set( clHandle, klientAnzahl );
		klientAnzahl++;
		cs.unlock();
		clHandle->start();
	}
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

bool ChatServer::hatClients() const
{
	return klientAnzahl > 0;
}

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

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

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

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


// Inhalt der CSAKlient Klasse aus ChatServer.h
// Konstruktor 
CSAKlient::CSAKlient( SKlient *klient, ChatServer *cs )
	: Thread()
{
	this->klient = klient;
	unsigned char key[ 20 ] = { 51, 206, 196, 230, 31, 97, 186, 90, 5, 0, 166, 28, 40, 141, 16, 55, 36, 181, 203, 236 };
	klient->setSendeKey( (char*)key, 20 );
	klient->setEmpfangKey( (char*)key, 20 );
	name = new Text( "" );
	passwort = new Text( "" );
	adminId = 0;
	this->cs = cs;
}

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

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

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


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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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