InformationServer/Information Server/InformationServer.cpp

#include "InformationServer.h"
#include <iostream>
#include <Klient.h>
#include <Globals.h>
#include "AccountHistorieDaten.h"

// Inhalt der InformationServer Klasse aus InformationServer.h
// Konstruktor 
InformationServer::InformationServer( InitDatei *zIni )
	: Thread()
{
	Network::Start( 100 );
	std::cout << "IS: Verbindung mit Datenbank wird hergestellt...\n";
	db = new ISDatenbank( zIni );
	klientAnzahl = 0;
	klients = new RCArray< ISKlient >();
	empfangen = 0;
	gesendet = 0;
	fehler = new Text();
	ini = zIni->getThis();
	if( !db->serverAnmelden( zIni ) )
	{
		std::cout << "IS: Der Server konnte nicht in die Datenbank eingetragen werden:\n";
		Text *txt = db->getLetzterFehler();
		std::cout << txt->getText() << "\nDas Programm wird beendet.";
		txt->release();
		exit( 1 );
	}
	id = *zIni->zWert( "ServerId" );
	server = new Server();
	aServer = new Server();
	std::cout << "IS: Starten des Admin Servers...\n";
	if( !aServer->verbinde( (unsigned short)db->getAdminPort( id ), 10 ) )
	{
		std::cout << "IS: Der Admin Server konnte nicht gestartet werden. Das Programm wird beendet.\n";
		exit( 1 );
	}
	db->setServerStatus( id, 2 );
	end = 0;
	nichtPausiert = 0;
	InitializeCriticalSection( &cs );
	ref = 1;
	if( zIni->zWert( "Aktiv" )->istGleich( "TRUE" ) )
	{
		serverStarten();
		serverFortsetzen();
	}
}

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

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

void InformationServer::thread()
{
	while( 1 )
	{
		SKlient *klient;
		klient = server->getKlient();
		if( !klient )
			break;
		Framework::getThreadRegister()->cleanUpClosedThreads();
		ISKlient *clHandle = new ISKlient( klient, getThis() );
		EnterCriticalSection( &cs );
		klients->set( clHandle, klientAnzahl );
		klientAnzahl++;
		LeaveCriticalSection( &cs );
		clHandle->start();
	}
}

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

bool InformationServer::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 InformationServer::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->anhängen( db->getLetzterFehler() );
		return 0;
	}
	return 1;
}

bool InformationServer::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->anhängen( db->getLetzterFehler() );
		return 0;
	}
	return 1;
}

bool InformationServer::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 InformationServer::setMaxKlients( int mc )
{
	if( !db->setMaxClients( id, mc ) )
	{
		fehler->setText( "Die maximale Anzahl der Clients konnte nicht gesetzt werden:\n" );
		fehler->anhängen( db->getLetzterFehler() );
		return 0;
	}
	ini->setWert( "MaxClients", Text() += mc );
	return 1;
}

bool InformationServer::absturzKlient( int klientId )
{
	bool gefunden = 0;
	EnterCriticalSection( &cs );
	for( int i = 0; i < klientAnzahl; i++ )
	{
		if( klients->z( i )->getKlientNummer() == klientId )
		{
			klients->z( i )->absturz();
			klients->lösche( i );
			klientAnzahl--;
			gefunden = 1;
			break;
		}
	}
	LeaveCriticalSection( &cs );
	return gefunden;
}

bool InformationServer::removeKlient( ISKlient *zKlient )
{
	bool gefunden = 0;
	EnterCriticalSection( &cs );
	for( int i = 0; i < klientAnzahl; i++ )
	{
		if( klients->z( i ) == zKlient )
		{
			klients->lösche( i );
			klientAnzahl--;
			gefunden = 1;
			break;
		}
	}
	LeaveCriticalSection( &cs );
	return gefunden;
}

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

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

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

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

ISDatenbank *InformationServer::zDB() const
{
	return db;
}

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

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

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

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

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


// Inhalt der ISAKlient Klasse aus InformationServer.h
// Konstruktor 
ISAKlient::ISAKlient( SKlient *klient, InformationServer *is )
	: Thread()
{
	this->klient = klient;
	unsigned char schlüssel[ 20 ] = { 37, 231, 77, 95, 83, 98, 112, 98, 11, 225, 186, 227, 172, 168, 11, 22, 254, 142, 14, 22 };
	klient->setSendeSchlüssel( (char*)schlüssel, 20 );
	klient->setEmpfangSchlüssel( (char*)schlüssel, 20 );
	name = new Text( "" );
	passwort = new Text( "" );
	adminId = 0;
	this->is = is;
}

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

// nicht constant 
void ISAKlient::thread()
{
	while( 1 )
	{
		char c = 0;
		if( !klient->getNachrichtVerschlüsselt( &c, 1 ) )
			break;
		else
		{
			bool br = 0;
			switch( c )
			{
			case 1: // Login
				if( 1 )
				{
					klient->sendeVerschlüsselt( "\1", 1 );
					char nLän = 0;
					klient->getNachrichtVerschlüsselt( &nLän, 1 );
					char *n = new char[ nLän + 1 ];
					n[ nLän ] = 0;
					if( nLän )
						klient->getNachrichtVerschlüsselt( n, nLän );
					char pLän = 0;
					klient->getNachrichtVerschlüsselt( &pLän, 1 );
					char *p = new char[ pLän + 1 ];
					p[ pLän ] = 0;
					if( pLän )
						klient->getNachrichtVerschlüsselt( p, pLän );
					int adminId = is->zDB()->istAdministrator( n, p );
					if( adminId )
					{
						klient->sendeVerschlüsselt( "\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->sendeVerschlüsselt( "\1", 1 );
				break;
			case 3: // Trennen
				br = 1;
				klient->sendeVerschlüsselt( "\1", 1 );
				break;
			case 4: // Server starten
				if( !adminId )
					errorZuKlient( "Du musst dich einloggen." );
				else
				{
					if( is->zDB()->adminHatRecht( adminId, Admin_Recht::ISStarten ) )
					{
						if( !is->serverStarten() )
						{
							Text *err = new Text();
							err->anhängen( is->getLetzterFehler() );
							errorZuKlient( err->getText() );
							err->release();
						}
						else
							klient->sendeVerschlüsselt( "\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( is->zDB()->adminHatRecht( adminId, Admin_Recht::ISBeenden ) )
					{
						if( is->serverBeenden() )
							klient->sendeVerschlüsselt( "\1", 1 );
						else
						{
							Text *err = new Text();
							err->anhängen( is->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( is->läuft() )
					{
						if( is->zDB()->adminHatRecht( adminId, Admin_Recht::ISBeenden ) )
						{
							if( is->serverBeenden() )
								ok = 1;
							else
							{
								Text *err = new Text();
								err->anhängen( is->getLetzterFehler() );
								errorZuKlient( err->getText() );
								err->release();
							}
						}
						else
							errorZuKlient( "Du bist nicht berechtigt den Server zu beenden." );
					}
					else
						ok = 1;
					if( ok && is->hatClients() )
					{
						errorZuKlient( "Es sind noch Klients Online. Bitte versuche es später erneut." );
						break;
					}
					if( ok )
					{
						klient->sendeVerschlüsselt( "\1", 1 );
						std::cout << "IS: Der Server wird von Benutzer " << adminId << " heruntergefahren.\n";
						is->schließen();
						br = 1;
					}
				}
				break;
			case 7: // Progtamm abstürzen
				if( !adminId )
					errorZuKlient( "Du musst dich einloggen." );
				else
				{
					bool ok = 0;
					if( is->läuft() )
					{
						if( is->zDB()->adminHatRecht( adminId, Admin_Recht::ISBeenden ) )
						{
							is->serverBeenden();
							ok = 1;
						}
						else
							errorZuKlient( "Du bist nicht berechtigt den Server zu beenden." );
					}
					else
						ok = 1;
					if( ok )
					{
						klient->sendeVerschlüsselt( "\1", 1 );
						std::cout << "IS: Der Server wurde von Benutzer " << adminId << " terminiert.\n";
						is->schließen();
						br = 1;
					}
				}
				break;
			case 8: // Status Frage
				if( 1 )
				{
					char status = 0;
					if( is->läuft() )
					{
						status = 1;
						if( is->istAn() )
							status = 2;
					}
					klient->sendeVerschlüsselt( "\1", 1 );
					klient->sendeVerschlüsselt( &status, 1 );
				}
				break;
			case 9: // Server pausieren
				if( !adminId )
					errorZuKlient( "Du musst dich einloggen." );
				else
				{
					klient->sendeVerschlüsselt( "\1", 1 );
					char pause = 0;
					klient->getNachrichtVerschlüsselt( &pause, 1 );
					if( is->zDB()->adminHatRecht( adminId, Admin_Recht::ISPausieren ) )
					{
						bool ok = 0;
						if( pause )
							ok = is->serverPause();
						else
							ok = is->serverFortsetzen();
						if( ok )
							klient->sendeVerschlüsselt( "\1", 1 );
						else
						{
							Text *err = new Text();
							err->anhängen( is->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->sendeVerschlüsselt( "\1", 1 );
					int maxC = 0;
					klient->getNachrichtVerschlüsselt( (char*)&maxC, 4 );
					if( is->zDB()->adminHatRecht( adminId, Admin_Recht::ISMCÄndern ) )
					{
						if( is->setMaxKlients( maxC ) )
							klient->sendeVerschlüsselt( "\1", 1 );
						else
						{
							Text *err = new Text();
							err->anhängen( is->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->sendeVerschlüsselt( "\1", 1 );
                    int klientId = 0;
                    klient->getNachrichtVerschlüsselt( (char*)&klientId, 4 );
                    if( klientId && is->absturzKlient( klientId ) )
                        klient->sendeVerschlüsselt( "\1", 1 );
                    else
                        klient->sendeVerschlüsselt( "\0", 1 );
                }
                break;
			default:
				errorZuKlient( "Unbekannte Nachricht!" );
				break;
			}
			if( br )
				break;
			is->addEmpfangen( klient->getDownloadBytes( 1 ) );
			is->addGesendet( klient->getUploadBytes( 1 ) );
		}
	}
	is->addEmpfangen( klient->getDownloadBytes( 1 ) );
	is->addGesendet( klient->getUploadBytes( 1 ) );
	delete this;
}

void ISAKlient::errorZuKlient( const char *nachricht ) const // sendet eine Fehlernachricht zum Klient
{
	klient->sendeVerschlüsselt( "\3", 1 );
	char län = textLänge( nachricht );
	klient->sendeVerschlüsselt( &län, 1 );
	klient->sendeVerschlüsselt( nachricht, län );
}


// Inhalt der ISKlient aus InformationServer.h
// Konstruktor 
ISKlient::ISKlient( SKlient *klient, InformationServer *is )
	: Thread()
{
	this->klient = klient;
	unsigned char schlüssel[ 20 ] = { 231, 246, 125, 32, 88, 172, 229, 223, 246, 138, 74, 64, 142, 245, 217, 218, 162, 62, 103, 50 };
	klient->setSendeSchlüssel( (char*)schlüssel, 20 );
	klient->setEmpfangSchlüssel( (char*)schlüssel, 20 );
	klientNummer = 0;
	this->is = is;
	ref = 1;
}

// Destruktor 
ISKlient::~ISKlient()
{
	klient->release();
	is->release();
}

// nicht constant
void ISKlient::absturz()
{
	ende();
	klient->trenne();
	is->zDB()->unregisterKlient( klientNummer, is->getId() );
}

void ISKlient::thread()
{
	while( 1 )
	{
		char c = 0;
		if( !klient->getNachrichtVerschlüsselt( &c, 1 ) )
			break;
		else
		{
			bool br = 0;
			switch( c )
			{
			case 1: // Klient identifikation
				klient->getNachrichtVerschlüsselt( (char*)&klientNummer, 4 );
				if( !is->zDB()->prüfKlient( klientNummer, is->getId() ) )
				{
					klientNummer = 0;
					errorZuKlient( "Du bist nicht für diesen Server eingetragen" );
				}
				else
				{
					Text *schlüssel = is->zDB()->getKlientSchlüssel( klientNummer );
					if( !schlüssel )
						errorZuKlient( "Es konnte kein Schlüssel ermittelt werden." );
					else
					{
						klient->sendeVerschlüsselt( "\1", 1 );
						klient->setEmpfangSchlüssel( *schlüssel, schlüssel->getLänge() );
						klient->setSendeSchlüssel( *schlüssel, schlüssel->getLänge() );
						schlüssel->release();
					}
				}
				break;
			case 2: // Main / Erhaltung Server message
				if( 1 )
				{
					char befehl = 0;
					klient->getNachrichtVerschlüsselt( &befehl, 1 );
					switch( befehl )
					{
					case 2: // klient absturtz
						if( 1 )
						{
							int klientId = 0;
							klient->getNachrichtVerschlüsselt( (char*)&klientId, 4 );
							if( klientId && is->absturzKlient( klientId ) )
								klient->sendeVerschlüsselt( "\1", 1 );
							else
								klient->sendeVerschlüsselt( "\0", 1 );
						}
						break;
					default:
						errorZuKlient( "Befehl nicht bekannt!" );
						break;
					}
				}
				break;
			case 3: // Verbindungsende
				br = 1;
				klient->sendeVerschlüsselt( "\1", 1 );
				break;
			case 4: // unregister Klient
				if( !klientNummer )
				{
					errorZuKlient( "Du bist nicht Identifiziert." );
					break;
				}
				is->zDB()->unregisterKlient( klientNummer, is->getId() );
				klient->sendeVerschlüsselt( "\1", 1 );
				break;
			case 5: // frage nach Informations Text
				if( 1 )
				{
					if( !klientNummer )
					{
						errorZuKlient( "Du bist nicht Identifiziert." );
						break;
					}
					klient->sendeVerschlüsselt( "\1", 1 );
					char typ = 0;
					Text *info = is->zDB()->getInformationsText( &typ );
					unsigned short län = info ? (unsigned short)info->getLänge() : 0;
					klient->sendeVerschlüsselt( (char*)&län, 2 );
					if( län > 0 )
						klient->sendeVerschlüsselt( info->getText(), län );
					klient->sendeVerschlüsselt( &typ, 1 );
					if( info )
						info->release();
				}
				break;
			case 6: // frage, ob Spiel erlaubt ist
				if( 1 )
				{
					if( !klientNummer )
					{
						errorZuKlient( "Du bist nicht Identifiziert." );
						break;
					}
					klient->sendeVerschlüsselt( "\1", 1 );
					int spielId = 0;
					klient->getNachrichtVerschlüsselt( (char*)&spielId, 4 );
					if( is->zDB()->istSpielErlaubt( spielId ) )
						klient->sendeVerschlüsselt( "\1", 1 );
					else
						klient->sendeVerschlüsselt( "\0", 1 );
				}
				break;
			case 7: // frage, ob Karte erlaubt ist
				if( 1 )
				{
					if( !klientNummer )
					{
						errorZuKlient( "Du bist nicht Identifiziert." );
						break;
					}
					klient->sendeVerschlüsselt( "\1", 1 );
					int karteId = 0;
					klient->getNachrichtVerschlüsselt( (char*)&karteId, 4 );
					if( is->zDB()->istKarteErlaubt( karteId ) )
						klient->sendeVerschlüsselt( "\1", 1 );
					else
						klient->sendeVerschlüsselt( "\0", 1 );
				}
				break;
			case 8: // Frage nach Spiel Id
				if( 1 )
				{
					if( !klientNummer )
					{
						errorZuKlient( "Du bist nicht Identifiziert." );
						break;
					}
					klient->sendeVerschlüsselt( "\1", 1 );
					char län = 0;
					klient->getNachrichtVerschlüsselt( &län, 1 );
					char *name = new char[ län + 1 ];
					name[ län ] = 0;
					klient->getNachrichtVerschlüsselt( name, län );
					int id = is->zDB()->getSpielId( name );
					klient->sendeVerschlüsselt( (char*)&id, 4 );
					delete[] name;
				}
				break;
			case 9: // Frage nach Karte Id
				if( 1 )
				{
					if( !klientNummer )
					{
						errorZuKlient( "Du bist nicht Identifiziert." );
						break;
					}
					klient->sendeVerschlüsselt( "\1", 1 );
					char län = 0;
					klient->getNachrichtVerschlüsselt( &län, 1 );
					char *name = new char[ län + 1 ];
					name[ län ] = 0;
					klient->getNachrichtVerschlüsselt( name, län );
					int id = is->zDB()->getKarteId( name );
					klient->sendeVerschlüsselt( (char*)&id, 4 );
					delete[] name;
				}
				break;
			case 0xA: // Frage nach Account rufName
				if( 1 )
				{
					if( !klientNummer )
					{
						errorZuKlient( "Du bist nicht Identifiziert." );
						break;
					}
					klient->sendeVerschlüsselt( "\1", 1 );
					int accountId = 0;
					klient->getNachrichtVerschlüsselt( (char*)&accountId, 4 );
					Text *rName = is->zDB()->getAccountRufName( accountId );
					if( rName )
					{
						char län = (char)rName->getLänge();
						klient->sendeVerschlüsselt( &län, 1 );
						klient->sendeVerschlüsselt( rName->getText(), län );
						rName->release();
					}
					else
						klient->sendeVerschlüsselt( "\0", 1 );
				}
				break;
			case 0xB: // Frage nach Spiel Statistik
				if( 1 )
				{
					if( !klientNummer )
					{
						errorZuKlient( "Du bist nicht Identifiziert." );
						break;
					}
					klient->sendeVerschlüsselt( "\1", 1 );
					int accountId = 0;
					int spielId = 0;
					klient->getNachrichtVerschlüsselt( (char*)&accountId, 4 );
					klient->getNachrichtVerschlüsselt( (char*)&spielId, 4 );
					Array< int > *values = is->zDB()->getAccountSpielStatistik( accountId, spielId );
					for( int i = 0; i < 10; i++ )
					{
						int tmp = values ? values->get( i ) : 0;
						klient->sendeVerschlüsselt( (char*)&tmp, 4 );
					}
					if( values )
						values->release();
				}
				break;
			case 0xC: // Frage nach Spieler Liste
				if( !klientNummer )
				{
					errorZuKlient( "Du bist nicht Identifiziert." );
					break;
				}
				else
				{
					klient->sendeVerschlüsselt( "\1", 1 );
					char län = 0;
					klient->getNachrichtVerschlüsselt( &län, 1 );
					char *suche = new char[ län + 1 ];
					suche[ län ] = 0;
					klient->getNachrichtVerschlüsselt( suche, län );
					int seite = 0;
					klient->getNachrichtVerschlüsselt( (char*)&seite, 4 );
					char sortSpalte = 0;
					char rückwärts = 0;
					klient->getNachrichtVerschlüsselt( &sortSpalte, 1 );
					klient->getNachrichtVerschlüsselt( &rückwärts, 1 );
					int maxSeite = 0;
					Result list = is->zDB()->getSpielerListe( suche, &seite, &maxSeite, sortSpalte, rückwärts != 0 );
					delete[] suche;
					klient->sendeVerschlüsselt( (char*)&seite, 4 );
					klient->sendeVerschlüsselt( (char*)&maxSeite, 4 );
					klient->sendeVerschlüsselt( (char*)&list.zeilenAnzahl, 4 );
					for( int i = 0; i < list.zeilenAnzahl; i++ )
					{
						int accId = list.values[ i * 6 ];
						klient->sendeVerschlüsselt( (char*)&accId, 4 );
						län = (char)list.values[ i * 6 + 1 ].getLänge();
						klient->sendeVerschlüsselt( &län, 1 );
						klient->sendeVerschlüsselt( list.values[ i * 6 + 1 ], län );
						län = (char)list.values[ i * 6 + 2 ].getLänge();
						klient->sendeVerschlüsselt( &län, 1 );
						klient->sendeVerschlüsselt( list.values[ i * 6 + 2 ], län );
						län = (char)list.values[ i * 6 + 3 ].getLänge();
						klient->sendeVerschlüsselt( &län, 1 );
						klient->sendeVerschlüsselt( list.values[ i * 6 + 3 ], län );
						län = (char)list.values[ i * 6 + 4 ].getLänge();
						klient->sendeVerschlüsselt( &län, 1 );
						klient->sendeVerschlüsselt( list.values[ i * 6 + 4 ], län );
						län = (char)list.values[ i * 6 + 5 ].getLänge();
						klient->sendeVerschlüsselt( &län, 1 );
						klient->sendeVerschlüsselt( list.values[ i * 6 + 5 ], län );
					}
					list.destroy();
				}
				break;
			case 0xD: // Frage nach Gruppe Karte Id
				if( 1 )
				{
					if( !klientNummer )
					{
						errorZuKlient( "Du bist nicht Identifiziert." );
						break;
					}
					klient->sendeVerschlüsselt( "\1", 1 );
					int gruppeId = 0;
					klient->getNachrichtVerschlüsselt( (char*)&gruppeId, 4 );
					int karteId = is->zDB()->getGruppenKarteId( gruppeId );
					klient->sendeVerschlüsselt( (char*)&karteId, 4 );
				}
				break;
			case 0xE: // Frage nach Karten Name
				if( 1 )
				{
					if( !klientNummer )
					{
						errorZuKlient( "Du bist nicht Identifiziert." );
						break;
					}
					klient->sendeVerschlüsselt( "\1", 1 );
					int karteId = 0;
					klient->getNachrichtVerschlüsselt( (char*)&karteId, 4 );
					Text *name = is->zDB()->getKarteName( karteId );
					if( !name )
					{
						klient->sendeVerschlüsselt( "\0", 1 );
						break;
					}
					char län = name->getLänge();
					klient->sendeVerschlüsselt( &län, 1 );
					klient->sendeVerschlüsselt( name->getText(), län );
					name->release();
				}
				break;
			case 0xF: // Frage nach Spiel Name
				if( 1 )
				{
					if( !klientNummer )
					{
						errorZuKlient( "Du bist nicht Identifiziert." );
						break;
					}
					klient->sendeVerschlüsselt( "\1", 1 );
					int spielId = 0;
					klient->getNachrichtVerschlüsselt( (char*)&spielId, 4 );
					Text *name = is->zDB()->getSpielName( spielId );
					if( !name )
					{
						klient->sendeVerschlüsselt( "\0", 1 );
						break;
					}
					char län = name->getLänge();
					klient->sendeVerschlüsselt( &län, 1 );
					klient->sendeVerschlüsselt( name->getText(), län );
					name->release();
				}
				break;
			case 0x10: // Frage nach Chatroom Name
				if( 1 )
				{
					if( !klientNummer )
					{
						errorZuKlient( "Du bist nicht Identifiziert." );
						break;
					}
					klient->sendeVerschlüsselt( "\1", 1 );
					int chatroomId = 0;
					klient->getNachrichtVerschlüsselt( (char*)&chatroomId, 4 );
					Text *name = is->zDB()->getChatroomName( chatroomId );
					if( !name )
					{
						klient->sendeVerschlüsselt( "\0", 1 );
						break;
					}
					char län = name->getLänge();
					klient->sendeVerschlüsselt( &län, 1 );
					klient->sendeVerschlüsselt( name->getText(), län );
					name->release();
				}
				break;
			case 0x11: // Frage nach Spiel Id
				if( 1 )
				{
					if( !klientNummer )
					{
						errorZuKlient( "Du bist nicht Identifiziert." );
						break;
					}
					klient->sendeVerschlüsselt( "\1", 1 );
					int karteId = 0;
					klient->getNachrichtVerschlüsselt( (char*)&karteId, 4 );
					int spielId = is->zDB()->getSpielId( karteId );
					klient->sendeVerschlüsselt( (char*)&spielId, 4 );
				}
				break;
			case 0x12: // Frage nach Spieler Id
				if( 1 )
				{
					if( !klientNummer )
					{
						errorZuKlient( "Du bist nicht Identifiziert." );
						break;
					}
					klient->sendeVerschlüsselt( "\1", 1 );
					char län = 0;
					klient->getNachrichtVerschlüsselt( &län, 1 );
					if( län )
					{
						char *name = new char[ län + 1 ];
						name[ län ] = 0;
						klient->getNachrichtVerschlüsselt( name, län );
						int id = is->zDB()->getAccountId( name );
						klient->sendeVerschlüsselt( (char*)&id, 4 );
						delete[]name;
					}
				}
				break;
			case 0x13: // Frage nach Chatroom Id
				if( 1 )
				{
					if( !klientNummer )
					{
						errorZuKlient( "Du bist nicht Identifiziert." );
						break;
					}
					klient->sendeVerschlüsselt( "\1", 1 );
					char län = 0;
					klient->getNachrichtVerschlüsselt( &län, 1 );
					if( län )
					{
						char *name = new char[ län + 1 ];
						name[ län ] = 0;
						klient->getNachrichtVerschlüsselt( name, län );
						int id = is->zDB()->getChatroomId( name );
						klient->sendeVerschlüsselt( (char*)&id, 4 );
						delete[]name;
					}
				}
				break;
			case 0x14: // Frage nach Spiel Punkten
				if( 1 )
				{
					if( !klientNummer )
					{
						errorZuKlient( "Du bist nicht Identifiziert." );
						break;
					}
					klient->sendeVerschlüsselt( "\1", 1 );
					int spielId = 0;
					int accountId = 0;
					klient->getNachrichtVerschlüsselt( (char*)&spielId, 4 );
					klient->getNachrichtVerschlüsselt( (char*)&accountId, 4 );
					int ret = is->zDB()->getSpielerPunkte( spielId, accountId );
					klient->sendeVerschlüsselt( (char*)&ret, 4 );
				}
				break;
			case 0x15: // Frage nach Gruppe Administrator
				if( 1 )
				{
					if( !klientNummer )
					{
						errorZuKlient( "Du bist nicht Identifiziert." );
						break;
					}
					klient->sendeVerschlüsselt( "\1", 1 );
					int gruppeId = 0;
					klient->getNachrichtVerschlüsselt( (char*)&gruppeId, 4 );
					int ret = is->zDB()->getGruppeAdminId( gruppeId );
					klient->sendeVerschlüsselt( (char*)&ret, 4 );
				}
				break;
			case 0x16: // Frage nach Spiel Liste
				if( klientNummer )
				{
					klient->sendeVerschlüsselt( "\1", 1 );
					Array< int > *list = is->zDB()->getAccountSpielArtListe( klientNummer );
					if( !list )
					{
						klient->sendeVerschlüsselt( "\0\0\0\0", 4 );
						break;
					}
					int anz = list->getEintragAnzahl();
					klient->sendeVerschlüsselt( (char*)&anz, 4 );
					for( int i = 0; i < anz; i++ )
					{
						int id = list->get( i );
						klient->sendeVerschlüsselt( (char*)&id, 4 );
					}
				}
				else
					errorZuKlient( "Du bist nicht Identifiziert." );
				break;
			case 0x17: // Frage nach neuster Spiel Version
				if( klientNummer )
				{
					klient->sendeVerschlüsselt( "\1", 1 );
					int id = 0;
					klient->getNachrichtVerschlüsselt( (char*)&id, 4 );
					int v = is->zDB()->getNeusteSpielVersion( id );
					klient->sendeVerschlüsselt( (char*)&v, 4 );
				}
				else
					errorZuKlient( "Du bist nicht Identifiziert." );
				break;
			case 0x18: // Frage nach Kupfer
				if( klientNummer )
				{
					klient->sendeVerschlüsselt( "\1", 1 );
					int k = is->zDB()->getKupfer( klientNummer );
					klient->sendeVerschlüsselt( (char*)&k, 4 );
				}
				else
					errorZuKlient( "Du bist nicht Identifiziert." );
				break;
			case 0x19: // Frage nach Dateigruppen Id von Spiel
				if( klientNummer )
				{
					klient->sendeVerschlüsselt( "\1", 1 );
					int spielId = 0;
					klient->getNachrichtVerschlüsselt( (char*)&spielId, 4 );
					int dgId = is->zDB()->getDateiGruppeVonSpiel( spielId );
					klient->sendeVerschlüsselt( (char*)&dgId, 4 );
				}
				else
					errorZuKlient( "Du bist nicht Identifiziert." );
				break;
			case 0x1A: // Frage nach Dateigruppen Pfad
				if( klientNummer )
				{
					klient->sendeVerschlüsselt( "\1", 1 );
					int dgId = 0;
					klient->getNachrichtVerschlüsselt( (char*)&dgId, 4 );
					Text *pf = is->zDB()->getDateiGruppePfad( dgId );
					if( !pf )
						errorZuKlient( "Die Dateigruppe wurde nicht gefunden." );
					else
					{
						klient->sendeVerschlüsselt( "\1", 1 );
						char län = pf->getLänge();
						klient->sendeVerschlüsselt( &län, 1 );
						if( län )
							klient->sendeVerschlüsselt( pf->getText(), län );
						pf->release();
					}
				}
				else
					errorZuKlient( "Du bist nicht Identifiziert." );
				break;
			case 0x1B: // Frage nach karte Liste
				if( klientNummer )
				{
					klient->sendeVerschlüsselt( "\1", 1 );
					int spielId = 0;
					klient->getNachrichtVerschlüsselt( (char*)&spielId, 4 );
					Array< int > *list = is->zDB()->getAccountKarteListe( klientNummer, spielId );
					if( !list )
					{
						klient->sendeVerschlüsselt( "\0\0\0\0", 4 );
						break;
					}
					int anz = list->getEintragAnzahl();
					klient->sendeVerschlüsselt( (char*)&anz, 4 );
					for( int i = 0; i < anz; i++ )
					{
						int id = list->get( i );
						klient->sendeVerschlüsselt( (char*)&id, 4 );
					}
				}
				else
					errorZuKlient( "Du bist nicht Identifiziert." );
				break;
			case 0x1E: // Frage nach Gruppe Spieler Hinzufügen
				if( klientNummer )
				{
					klient->sendeVerschlüsselt( "\1", 1 );
					int gruppeId = 0;
					klient->getNachrichtVerschlüsselt( (char*)&gruppeId, 4 );
					char gSH = (char)is->zDB()->getGruppeSpielerHinzufügen( gruppeId );
					klient->sendeVerschlüsselt( &gSH, 1 );
				}
				else
					errorZuKlient( "Du bist nicht Identifiziert." );
				break;
			case 0x1F: // Frage nach Spieler Aktivität
				if( klientNummer )
				{
					klient->sendeVerschlüsselt( "\1", 1 );
					int acc = 0;
					klient->getNachrichtVerschlüsselt( (char*)&acc, 4 );
					RCArray< Text > *datum = new RCArray< Text >();
					Array< double > *stOnline = new Array< double >();
					Array< double > *stSpiel = new Array< double >();
					Array< int > *anzSpiele = new Array< int >();
					Array< int > *anzGewonnen = new Array< int >();
					if( is->zDB()->getSpielerAktivität( acc, datum, stOnline, stSpiel, anzSpiele, anzGewonnen ) )
					{
						klient->sendeVerschlüsselt( "\1", 1 );
						int anz = datum->getEintragAnzahl();
						for( int i = 0; i < anz; i++ )
						{
							if( datum->z( i ) )
							{
								char län = (char)datum->get( i )->getLänge();
								if( län )
								{
									klient->sendeVerschlüsselt( &län, 1 );
									klient->sendeVerschlüsselt( datum->z( i )->getText(), län );
									double sto = stOnline->hat( i ) ? stOnline->get( i ) : 0;
									klient->sendeVerschlüsselt( (char*)&sto, 8 );
									double sts = stSpiel->hat( i ) ? stSpiel->get( i ) : 0;
									klient->sendeVerschlüsselt( (char*)&sts, 8 );
									int anzs = anzSpiele->hat( i ) ? anzSpiele->get( i ) : 0;
									klient->sendeVerschlüsselt( (char*)&anzs, 4 );
									int anzg = anzGewonnen->hat( i ) ? anzGewonnen->get( i ) : 0;
									klient->sendeVerschlüsselt( (char*)&anzg, 4 );
								}
							}
						}
						klient->sendeVerschlüsselt( "\0", 1 );
					}
					else
						errorZuKlient( "Keine Daten gefunden." );
					datum->release();
					stOnline->release();
					stSpiel->release();
					anzSpiele->release();
					anzGewonnen->release();
				}
				else
					errorZuKlient( "Du bist nicht Identifiziert." );
				break;
			case 0x20: // Frage nach Anzahl der gespielten Spiele von Karte
				if( klientNummer )
				{
					klient->sendeVerschlüsselt( "\1", 1 );
					int acc = 0;
					int karte = 0;
					klient->getNachrichtVerschlüsselt( (char*)&acc, 4 );
					klient->getNachrichtVerschlüsselt( (char*)&karte, 4 );
					int anz = is->zDB()->getAccountKarteSpiele( acc, karte );
					klient->sendeVerschlüsselt( (char*)&anz, 4 );
				}
				else
					errorZuKlient( "Du bist nicht Identifiziert." );
				break;
			case 0x21: // Frage nach Anzahl gewonnener Spiele von Karte
				if( klientNummer )
				{
					klient->sendeVerschlüsselt( "\1", 1 );
					int acc = 0;
					int karte = 0;
					klient->getNachrichtVerschlüsselt( (char*)&acc, 4 );
					klient->getNachrichtVerschlüsselt( (char*)&karte, 4 );
					int anz = is->zDB()->getAccountKarteSpieleGewonnen( acc, karte );
					klient->sendeVerschlüsselt( (char*)&anz, 4 );
				}
				else
					errorZuKlient( "Du bist nicht Identifiziert." );
				break;
			case 0x22: // Frage nach Besitz Status von Karte
				if( klientNummer )
				{
					klient->sendeVerschlüsselt( "\1", 1 );
					int acc = 0;
					int karte = 0;
					klient->getNachrichtVerschlüsselt( (char*)&acc, 4 );
					klient->getNachrichtVerschlüsselt( (char*)&karte, 4 );
					char status = (char)is->zDB()->hatAccountKarte( acc, karte );
					klient->sendeVerschlüsselt( &status, 1 );
				}
				else
					errorZuKlient( "Du bist nicht Identifiziert." );
				break;
			case 0x23: // Frage nach Besitz Status von Spiel
				if( klientNummer )
				{
					klient->sendeVerschlüsselt( "\1", 1 );
					int acc = 0;
					int spiel = 0;
					klient->getNachrichtVerschlüsselt( (char*)&acc, 4 );
					klient->getNachrichtVerschlüsselt( (char*)&spiel, 4 );
					char status = (char)is->zDB()->hatAccountSpiel( acc, spiel );
					klient->sendeVerschlüsselt( &status, 1 );
				}
				else
					errorZuKlient( "Du bist nicht Identifiziert." );
				break;
			case 0x24: // Frage nach Liste mit gespielten Karten
				if( klientNummer )
				{
					klient->sendeVerschlüsselt( "\1", 1 );
					int acc = 0;
					int spiel = 0;
					klient->getNachrichtVerschlüsselt( (char*)&acc, 4 );
					klient->getNachrichtVerschlüsselt( (char*)&spiel, 4 );
					Array< int > *res = is->zDB()->getAccountKarteGespieltListe( acc, spiel );
					if( res )
					{
						int anz = res->getEintragAnzahl();
						klient->sendeVerschlüsselt( (char*)&anz, 4 );
						for( int i = 0; i < anz; i++ )
						{
							int val = res->get( i );
							klient->sendeVerschlüsselt( (char*)&val, 4 );
						}
						res->release();
					}
					else
						klient->sendeVerschlüsselt( "\0\0\0\0", 4 );
				}
				else
					errorZuKlient( "Du bist nicht Identifiziert." );
				break;
			case 0x25: // Frage nach Liste mit gespielten Spielen
				if( klientNummer )
				{
					klient->sendeVerschlüsselt( "\1", 1 );
					int acc = 0;
					klient->getNachrichtVerschlüsselt( (char*)&acc, 4 );
					Array< int > *res = is->zDB()->getAccountSpielGespieltListe( acc );
					if( res )
					{
						int anz = res->getEintragAnzahl();
						klient->sendeVerschlüsselt( (char*)&anz, 4 );
						for( int i = 0; i < anz; i++ )
						{
							int val = res->get( i );
							klient->sendeVerschlüsselt( (char*)&val, 4 );
						}
						res->release();
					}
					else
						klient->sendeVerschlüsselt( "\0\0\0\0", 4 );
				}
				else
					errorZuKlient( "Du bist nicht Identifiziert." );
				break;
			case 0x26: // Frage nach Liste mit spiel Partnern
				if( klientNummer )
				{
					klient->sendeVerschlüsselt( "\1", 1 );
					int acc = 0;
					klient->getNachrichtVerschlüsselt( (char*)&acc, 4 );
					Result res = is->zDB()->getSpielPartnerListe( acc );
					klient->sendeVerschlüsselt( (char*)&res.zeilenAnzahl, 4 );
					for( int i = 0; i < res.zeilenAnzahl; i++ )
					{
						int spieler = res.values[ i * 3 ];
						int anzahl = res.values[ i * 3 + 1 ];
						int karte = res.values[ i * 3 + 2 ];
						klient->sendeVerschlüsselt( (char*)&spieler, 4 );
						klient->sendeVerschlüsselt( (char*)&karte, 4 );
						klient->sendeVerschlüsselt( (char*)&anzahl, 4 );
					}
					res.destroy();
				}
				else
					errorZuKlient( "Du bist nicht Identifiziert." );
				break;
			case 0x27: // Frage nach Liste mit spiel Statistiken
				if( klientNummer )
				{
					klient->sendeVerschlüsselt( "\1", 1 );
					int acc = 0;
					klient->getNachrichtVerschlüsselt( (char*)&acc, 4 );
					int seite = 0;
					klient->getNachrichtVerschlüsselt( (char*)&seite, 4 );
					char sortSpalte = 0;
					char rückwärts = 0;
					klient->getNachrichtVerschlüsselt( &sortSpalte, 1 );
					klient->getNachrichtVerschlüsselt( &rückwärts, 1 );
					int maxSeite = 0;
					Result list = is->zDB()->getSpielStatistikListe( acc, &seite, &maxSeite, sortSpalte, rückwärts != 0 );
					klient->sendeVerschlüsselt( (char*)&seite, 4 );
					klient->sendeVerschlüsselt( (char*)&maxSeite, 4 );
					klient->sendeVerschlüsselt( (char*)&list.zeilenAnzahl, 4 );
					klient->sendeVerschlüsselt( (char*)&list.feldAnzahl, 4 );
					for( int i = 0; i < list.zeilenAnzahl; i++ )
					{
						for( int j = 0; j < list.feldAnzahl; j++ )
						{
							if( j != 1 )
							{
								int val = list.values[ j + i * list.feldAnzahl ];
								klient->sendeVerschlüsselt( (char*)&val, 4 );
							}
							else
							{
								char län = list.values[ j + i * list.feldAnzahl ].getLänge();
								klient->sendeVerschlüsselt( &län, 1 );
								if( län )
									klient->sendeVerschlüsselt( list.values[ j + i * list.feldAnzahl ], län );
							}
						}
					}
					list.destroy();
				}
				else
					errorZuKlient( "Du bist nicht Identifiziert." );
				break;
			case 0x28: // Spiel Historie Liste
				if( klientNummer )
				{
					klient->sendeVerschlüsselt( "\1", 1 );
					int acc = 0;
					klient->getNachrichtVerschlüsselt( (char*)&acc, 4 );
					AHDaten *daten = is->zDB()->getSpielHistorie( acc, is );
					if( daten )
					{
						char anz = (char)daten->spiele->getEintragAnzahl();
						klient->sendeVerschlüsselt( &anz, 1 );
						for( char i = 0; i < anz; i++ )
						{
							AHSpielDaten *spiel = daten->spiele->z( i );
							klient->sendeVerschlüsselt( (char*)&spiel->id, 4 );
							klient->sendeVerschlüsselt( (char*)&spiel->karteId, 4 );
							char län = (char)spiel->spiel->getLänge();
							klient->sendeVerschlüsselt( &län, 1 );
							if( län )
								klient->sendeVerschlüsselt( *spiel->spiel, län );
							län = (char)spiel->karte->getLänge();
							klient->sendeVerschlüsselt( &län, 1 );
							if( län )
								klient->sendeVerschlüsselt( *spiel->karte, län );
							län = (char)spiel->datum->getLänge();
							klient->sendeVerschlüsselt( &län, 1 );
							if( län )
								klient->sendeVerschlüsselt( *spiel->datum, län );
							län = (char)spiel->status->getLänge();
							klient->sendeVerschlüsselt( &län, 1 );
							if( län )
								klient->sendeVerschlüsselt( *spiel->status, län );
							län = (char)spiel->dauer->getLänge();
							klient->sendeVerschlüsselt( &län, 1 );
							if( län )
								klient->sendeVerschlüsselt( *spiel->dauer, län );
							län = (char)spiel->spielStatus->getLänge();
							klient->sendeVerschlüsselt( &län, 1 );
							if( län )
								klient->sendeVerschlüsselt( *spiel->spielStatus, län );
							län = (char)spiel->gewinner->getLänge();
							klient->sendeVerschlüsselt( &län, 1 );
							if( län )
								klient->sendeVerschlüsselt( *spiel->gewinner, län );
							klient->sendeVerschlüsselt( (char*)&spiel->sAnzahl, 4 );
							char tAnz = (char)spiel->teams->getEintragAnzahl();
							klient->sendeVerschlüsselt( &tAnz, 1 );
							for( char j = 0; j < tAnz; j++ )
							{
								AHSpielTeamDaten *team = spiel->teams->z( j );
								char län = (char)team->name->getLänge();
								klient->sendeVerschlüsselt( &län, 1 );
								if( län )
									klient->sendeVerschlüsselt( *team->name, län );
								klient->sendeVerschlüsselt( (char*)&team->sAnzahl, 4 );
								län = (char)team->status->getLänge();
								klient->sendeVerschlüsselt( &län, 1 );
								if( län )
									klient->sendeVerschlüsselt( *team->status, län );
								klient->sendeVerschlüsselt( (char*)&team->farbe, 4 );
								char sAnz = (char)team->spieler->getEintragAnzahl();
								klient->sendeVerschlüsselt( &sAnz, 1 );
								for( char k = 0; k < sAnz; k++ )
								{
									AHSpielSpielerDaten *spieler = team->spieler->z( k );
									char län = (char)spieler->name->getLänge();
									klient->sendeVerschlüsselt( &län, 1 );
									if( län )
										klient->sendeVerschlüsselt( *spieler->name, län );
									klient->sendeVerschlüsselt( (char*)&spieler->punkte, 4 );
									län = (char)spieler->status->getLänge();
									klient->sendeVerschlüsselt( &län, 1 );
									if( län )
										klient->sendeVerschlüsselt( *spieler->status, län );
									klient->sendeVerschlüsselt( (char*)&spieler->farbe, 4 );
								}
							}
						}
						daten->release();
					}
					else
						klient->sendeVerschlüsselt( "\0", 1 );
				}
				else
					errorZuKlient( "Du bist nicht Identifiziert." );
				break;
			case 0x29: // Frage nach Historie Server
				if( klientNummer )
				{
					klient->sendeVerschlüsselt( "\1", 1 );
					int spielId = 0;
					klient->getNachrichtVerschlüsselt( (char*)&spielId, 4 );
					int port = 0;
					Text *ip = new Text();
					if( is->zDB()->getHistorieServerPortIp( klientNummer, spielId, &port, ip ) )
					{
						klient->sendeVerschlüsselt( "\1", 1 );
						klient->sendeVerschlüsselt( (char*)&port, 4 );
						char län = (char)ip->getLänge();
						klient->sendeVerschlüsselt( &län, 1 );
						klient->sendeVerschlüsselt( *ip, län );
					}
					else
						errorZuKlient( "Die Daten für dieses Spiel sind vorrübergehend nicht verfügbar." );
					ip->release();
				}
				else
					errorZuKlient( "Du bist nicht Identifiziert." );
				break;
			case 0x2A: // Frage nach Dateigruppen Id von Pfad
				if( klientNummer )
				{
					klient->sendeVerschlüsselt( "\1", 1 );
					char län = 0;
					klient->getNachrichtVerschlüsselt( (char*)&län, 1 );
					char *pf = new char[ län + 1 ];
					pf[ län ] = 0;
					klient->getNachrichtVerschlüsselt( (char*)pf, län );
					int dgId = is->zDB()->getDateiGruppeVonPfad( pf );
					delete[] pf;
					klient->sendeVerschlüsselt( (char*)&dgId, 4 );
				}
				else
					errorZuKlient( "Du bist nicht Identifiziert." );
				break;
			case 0x2B: // Frage nach neuster Version einer Dateigruppe
				if( klientNummer )
				{
					klient->sendeVerschlüsselt( "\1", 1 );
					int dg = 0;
					klient->getNachrichtVerschlüsselt( (char*)&dg, 4 );
					int v = is->zDB()->getNeusteDateiGruppe( dg );
					klient->sendeVerschlüsselt( (char*)&v, 4 );
				}
				else
					errorZuKlient( "Du bist nicht Identifiziert." );
				break;
			case 0x2C: // ping
				if( 1 )
				{
					if( !klientNummer )
					{
						errorZuKlient( "Du bist nicht Identifiziert." );
						break;
					}
					klient->sendeVerschlüsselt( "\1", 1 );
				}
				break;
			case 0x2D: // Hat Account Recht
				if( !klientNummer )
				{
					errorZuKlient( "Du bist nicht Identifiziert." );
					break;
				}
				else
				{
					klient->sendeVerschlüsselt( "\1", 1 );
					int recht = 0;
					klient->getNachrichtVerschlüsselt( (char*)&recht, 4 );
					if( is->zDB()->hatKlientRecht( klientNummer, recht ) )
						klient->sendeVerschlüsselt( "\1", 1 );
					else
						klient->sendeVerschlüsselt( "\0", 1 );
				}
				break;
			case 0x2E: // Karten Liste
				if( !klientNummer )
				{
					errorZuKlient( "Du bist nicht Identifiziert." );
					break;
				}
				else
				{
					klient->sendeVerschlüsselt( "\1", 1 );
					char filterLän = 0;
					klient->getNachrichtVerschlüsselt( &filterLän, 1 );
					char *filter = new char[ filterLän + 1 ];
					filter[ filterLän ] = 0;
					if( filterLän )
						klient->getNachrichtVerschlüsselt( filter, filterLän );
					char sortSpalte = 0;
					klient->getNachrichtVerschlüsselt( &sortSpalte, 1 );
					char sortRichtung = 0;
					klient->getNachrichtVerschlüsselt( &sortRichtung, 1 );
					Result res = is->zDB()->getKartenListe( klientNummer, filter, sortSpalte, sortRichtung );
					delete[] filter;
					klient->sendeVerschlüsselt( (char*)&res.zeilenAnzahl, 4 );
					for( int i = 0; i < res.zeilenAnzahl; i++ )
					{
						int val = res.values[ i * 6 ];
						klient->sendeVerschlüsselt( (char*)&val, 4 );
						char län = (char)res.values[ i * 6 + 1 ].getLänge();
						klient->sendeVerschlüsselt( &län, 1 );
						if( län )
							klient->sendeVerschlüsselt( res.values[ i * 6 + 1 ], län );
						län = (char)res.values[ i * 6 + 2 ].getLänge();
						klient->sendeVerschlüsselt( &län, 1 );
						if( län )
							klient->sendeVerschlüsselt( res.values[ i * 6 + 2 ], län );
						val = res.values[ i * 6 + 3 ];
						klient->sendeVerschlüsselt( (char*)&val, 4 );
						val = res.values[ i * 6 + 4 ];
						klient->sendeVerschlüsselt( (char*)&val, 4 );
						val = res.values[ i * 6 + 5 ];
						klient->sendeVerschlüsselt( (char*)&val, 4 );
					}
					res.destroy();
				}
				break;
			case 0x2F: // Editor Server Anfrage
				if( !klientNummer )
				{
					errorZuKlient( "Du bist nicht Identifiziert." );
					break;
				}
				else
				{
					klient->sendeVerschlüsselt( "\1", 1 );
					int karteId = 0;
					klient->getNachrichtVerschlüsselt( (char*)&karteId, 4 );
					int port = 0;
					Text ip;
					if( !is->zDB()->getEditorServerPortIp( klientNummer, karteId, &port, &ip ) )
					{
						errorZuKlient( "Du kannst diese Karte momentan nicht abrufen." );
						break;
					}
					klient->sendeVerschlüsselt( "\1", 1 );
					klient->sendeVerschlüsselt( (char*)&port, 4 );
					char län = (char)ip.getLänge();
					klient->sendeVerschlüsselt( &län, 1 );
					klient->sendeVerschlüsselt( ip, län );
				}
                break;
            case 0x30: // Karten Server Anfrage
                if( !klientNummer )
                {
                    errorZuKlient( "Du bist nicht Identifiziert." );
                    break;
                }
                else
                {
                    klient->sendeVerschlüsselt( "\1", 1 );
                    int karteId = 0;
                    klient->getNachrichtVerschlüsselt( (char*)&karteId, 4 );
                    int port = 0;
                    Text ip;
                    if( !is->zDB()->getKartenServerPortIp( klientNummer, karteId, &port, &ip ) )
                    {
                        errorZuKlient( "Diese Karte ist vorrübergehend nicht erreichbar." );
                        break;
                    }
                    klient->sendeVerschlüsselt( "\1", 1 );
                    klient->sendeVerschlüsselt( (char*)&port, 4 );
                    char län = (char)ip.getLänge();
                    klient->sendeVerschlüsselt( &län, 1 );
                    klient->sendeVerschlüsselt( ip, län );
                }
                break;
			default:
				errorZuKlient( "Unbekannte Nachricht!" );
				break;
			}
			if( br )
				break;
			is->addEmpfangen( klient->getDownloadBytes( 1 ) );
			is->addGesendet( klient->getUploadBytes( 1 ) );
		}
	}
	is->addEmpfangen( klient->getDownloadBytes( 1 ) );
	is->addGesendet( klient->getUploadBytes( 1 ) );
	is->removeKlient( this ); // delete this
}

// constant
void ISKlient::errorZuKlient( const char *nachricht ) const // sendet eine Fehlernachricht zum Klient
{
	klient->sendeVerschlüsselt( "\3", 1 );
	char län = textLänge( nachricht );
	klient->sendeVerschlüsselt( &län, 1 );
	klient->sendeVerschlüsselt( nachricht, län );
}

int ISKlient::getKlientNummer() const // gibt die KlientId zurück
{
	return klientNummer;
}

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

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