ChatServer/ChatServer/ChatServer.cpp

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


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

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

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

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


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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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