framework changes

InformationServer/AccountHistorieDaten.cpp

@@ -3,95 +3,95 @@
 // Inhalt der AHSpielSpielerDaten Struktur aus AccountHistorieDaten.h
 // Konstruktor
 AHSpielSpielerDaten::AHSpielSpielerDaten()
-    : ReferenceCounter(),
-    name( new Text() ),
-    status( new Text() )
+	: ReferenceCounter(),
+	name(new Text()),
+	status(new Text())
 {}
 
 // Destruktor
 AHSpielSpielerDaten::~AHSpielSpielerDaten()
 {
-    name->release();
-    status->release();
+	name->release();
+	status->release();
 }
 
 
 // Inhalt der AHSpielTeamDaten Struktur aus AccountHistorieDaten.h
 // Konstruktor
 AHSpielTeamDaten::AHSpielTeamDaten()
-    : ReferenceCounter(),
-    name( new Text() ),
-    status( new Text() ),
-    spieler( new RCArray< AHSpielSpielerDaten >() )
+	: ReferenceCounter(),
+	name(new Text()),
+	status(new Text()),
+	spieler(new RCArray< AHSpielSpielerDaten >())
 {}
 
 // Destruktor
 AHSpielTeamDaten::~AHSpielTeamDaten()
 {
-    name->release();
-    status->release();
-    spieler->release();
+	name->release();
+	status->release();
+	spieler->release();
 }
 
 
 // Inhalt der AHSpielDaten Struktur aus AccountHistorieDaten.h
 // Konstruktor
 AHSpielDaten::AHSpielDaten()
-    : ReferenceCounter(),
-    spiel( new Text() ),
-    karte( new Text() ),
-    datum( new Text() ),
-    status( new Text() ),
-    dauer( new Text() ),
-    spielStatus( new Text() ),
-    gewinner( new Text() ),
-    teams( new RCArray< AHSpielTeamDaten >() )
+	: ReferenceCounter(),
+	spiel(new Text()),
+	karte(new Text()),
+	datum(new Text()),
+	status(new Text()),
+	dauer(new Text()),
+	spielStatus(new Text()),
+	gewinner(new Text()),
+	teams(new RCArray< AHSpielTeamDaten >())
 {}
 
 // Destruktor
 AHSpielDaten::~AHSpielDaten()
 {
-    spiel->release();
-    karte->release();
-    datum->release();
-    status->release();
-    dauer->release();
-    spielStatus->release();
-    gewinner->release();
-    teams->release();
+	spiel->release();
+	karte->release();
+	datum->release();
+	status->release();
+	dauer->release();
+	spielStatus->release();
+	gewinner->release();
+	teams->release();
 }
 
 
 // Inhalt der AHDaten Struktur aus AccountHistorieDaten.h
 // Konstruktor
 AHDaten::AHDaten()
-    : ReferenceCounter(),
-    spiele( new RCArray< AHSpielDaten >() )
+	: ReferenceCounter(),
+	spiele(new RCArray< AHSpielDaten >())
 {}
 
 // Destruktor
 AHDaten::~AHDaten()
 {
-    spiele->release();
+	spiele->release();
 }
 
 
 // Inhalt der SpielerTeamStruktur Struktur aus Strukturen.h
 SpielerTeamStruktur::SpielerTeamStruktur()
-    : ReferenceCounter()
+	: ReferenceCounter()
 {
-    spielerAnzahl = 0;
-    teamAnzahl = 0;
-    spielerFarbe = new Array< int >();
-    teamFarbe = new Array< int >();
-    teamName = new RCArray< Text >();
-    teamSize = new Array< int >();
+	spielerAnzahl = 0;
+	teamAnzahl = 0;
+	spielerFarbe = new Array< int >();
+	teamFarbe = new Array< int >();
+	teamName = new RCArray< Text >();
+	teamSize = new Array< int >();
 }
 
 SpielerTeamStruktur::~SpielerTeamStruktur()
 {
-    spielerFarbe->release();
-    teamFarbe->release();
-    teamName->release();
-    teamSize->release();
+	spielerFarbe->release();
+	teamFarbe->release();
+	teamName->release();
+	teamSize->release();
 }

InformationServer/AccountHistorieDaten.h

@@ -8,72 +8,72 @@ using namespace Framework;
 
 struct AHSpielSpielerDaten : public virtual ReferenceCounter
 {
-    Text *name;
-    int punkte;
-    Text *status;
-    int farbe;
+	Text* name;
+	int punkte;
+	Text* status;
+	int farbe;
 
-    // Konstruktor
-    AHSpielSpielerDaten();
-    // Destruktor
-    ~AHSpielSpielerDaten();
+	// Konstruktor
+	AHSpielSpielerDaten();
+	// Destruktor
+	~AHSpielSpielerDaten();
 };
 
 struct AHSpielTeamDaten : public virtual ReferenceCounter
 {
-    int id;
-    Text *name;
-    int sAnzahl;
-    Text *status;
-    int farbe;
-    RCArray< AHSpielSpielerDaten > *spieler;
+	int id;
+	Text* name;
+	int sAnzahl;
+	Text* status;
+	int farbe;
+	RCArray< AHSpielSpielerDaten >* spieler;
 
-    // Konstruktor
-    AHSpielTeamDaten();
-    // Destruktor
-    ~AHSpielTeamDaten();
+	// Konstruktor
+	AHSpielTeamDaten();
+	// Destruktor
+	~AHSpielTeamDaten();
 };
 
 struct AHSpielDaten : public virtual ReferenceCounter
 {
-    int id;
-    int karteId;
-    Text *spiel;
-    Text *karte;
-    Text *datum;
-    Text *status;
-    Text *dauer;
-    Text *spielStatus;
-    Text *gewinner;
-    int sAnzahl;
-    RCArray< AHSpielTeamDaten > *teams;
+	int id;
+	int karteId;
+	Text* spiel;
+	Text* karte;
+	Text* datum;
+	Text* status;
+	Text* dauer;
+	Text* spielStatus;
+	Text* gewinner;
+	int sAnzahl;
+	RCArray< AHSpielTeamDaten >* teams;
 
-    // Konstruktor
-    AHSpielDaten();
-    // Destruktor
-    ~AHSpielDaten();
+	// Konstruktor
+	AHSpielDaten();
+	// Destruktor
+	~AHSpielDaten();
 };
 
 struct AHDaten : public virtual ReferenceCounter
 {
-    RCArray< AHSpielDaten > *spiele;
+	RCArray< AHSpielDaten >* spiele;
 
-    // Konstruktor
-    AHDaten();
-    // Destruktor
-    ~AHDaten();
+	// Konstruktor
+	AHDaten();
+	// Destruktor
+	~AHDaten();
 };
 
 struct SpielerTeamStruktur : public virtual ReferenceCounter
 {
-    SpielerTeamStruktur();
-    ~SpielerTeamStruktur();
-    int spielerAnzahl;
-    int teamAnzahl;
-    Array< int > *spielerFarbe;
-    Array< int > *teamFarbe;
-    RCArray< Text > *teamName;
-    Array< int > *teamSize;
+	SpielerTeamStruktur();
+	~SpielerTeamStruktur();
+	int spielerAnzahl;
+	int teamAnzahl;
+	Array< int >* spielerFarbe;
+	Array< int >* teamFarbe;
+	RCArray< Text >* teamName;
+	Array< int >* teamSize;
 };
 
 #endif

InformationServer/Datenbank.cpp

@@ -5,1914 +5,1914 @@
 
 // Inhalt der LSDatenbank Klasse aus Datenbank.h
 // Konstruktor
-ISDatenbank::ISDatenbank( InitDatei *zIni )
-    : ReferenceCounter()
+ISDatenbank::ISDatenbank(InitDatei* zIni)
+	: ReferenceCounter()
 {
-    datenbank = new Datenbank( zIni->zWert( "DBBenutzer" )->getText(), zIni->zWert( "DBPasswort" )->getText(),
-                               zIni->zWert( "DBName" )->getText(), zIni->zWert( "DBIP" )->getText(),
-                               (unsigned short)TextZuInt( zIni->zWert( "DBPort" )->getText(), 10 ) );
-    if( !datenbank->istOk() )
-    {
-        std::cout << "IS: Die Verbindung zur Datenbank konnte nicht hergestellt werden.\nDas Programm wird beendet.";
-        exit( 1 );
-    }
-    InitializeCriticalSection( &cs );
-    Text befehl = "SELECT port, admin_port  FROM server WHERE id = ";
-    befehl += zIni->zWert( "ServerId" )->getText();
-    lock();
-    datenbank->befehl( befehl );
-    Result res = datenbank->getResult();
-    unlock();
-    if( res.zeilenAnzahl == 1 )
-    {
-        zIni->addWert( "ServerPort", res.values[ 0 ] );
-        zIni->addWert( "AdminServerPort", res.values[ 1 ] );
-    }
-    res.destroy();
+	datenbank = new Datenbank(zIni->zWert("DBBenutzer")->getText(), zIni->zWert("DBPasswort")->getText(),
+		zIni->zWert("DBName")->getText(), zIni->zWert("DBIP")->getText(),
+		(unsigned short)TextZuInt(zIni->zWert("DBPort")->getText(), 10));
+	if (!datenbank->istOk())
+	{
+		std::cout << "IS: Die Verbindung zur Datenbank konnte nicht hergestellt werden.\nDas Programm wird beendet.";
+		exit(1);
+	}
+	InitializeCriticalSection(&cs);
+	Text befehl = "SELECT port, admin_port  FROM server WHERE id = ";
+	befehl += zIni->zWert("ServerId")->getText();
+	lock();
+	datenbank->befehl(befehl);
+	Result res = datenbank->getResult();
+	unlock();
+	if (res.zeilenAnzahl == 1)
+	{
+		zIni->addWert("ServerPort", res.values[0]);
+		zIni->addWert("AdminServerPort", res.values[1]);
+	}
+	res.destroy();
 }
 
 // Destruktor
 ISDatenbank::~ISDatenbank()
 {
-    datenbank->release();
-    DeleteCriticalSection( &cs );
+	datenbank->release();
+	DeleteCriticalSection(&cs);
 }
 
 // nicht constant
 void ISDatenbank::lock()
 {
-    EnterCriticalSection( &cs );
+	EnterCriticalSection(&cs);
 }
 
 void ISDatenbank::unlock()
 {
-    LeaveCriticalSection( &cs );
+	LeaveCriticalSection(&cs);
 }
 
-int ISDatenbank::istAdministrator( const char *name, const char *passwort )
+int ISDatenbank::istAdministrator(const char* name, const char* passwort)
 {
-    Text *befehl = new Text( "SELECT id FROM benutzer WHERE name = '" );
-    befehl->append( name );
-    befehl->append( "' AND passwort = md5('" );
-    befehl->append( passwort );
-    befehl->append( "')" );
-    lock();
-    datenbank->befehl( befehl->getText() );
-    Result res = datenbank->getResult();
-    unlock();
-    befehl->release();
-    int ret = 0;
-    if( res.zeilenAnzahl > 0 )
-        ret = TextZuInt( res.values[ 0 ].getText(), 10 );
-    res.destroy();
-    return ret;
+	Text* befehl = new Text("SELECT id FROM benutzer WHERE name = '");
+	befehl->append(name);
+	befehl->append("' AND passwort = md5('");
+	befehl->append(passwort);
+	befehl->append("')");
+	lock();
+	datenbank->befehl(befehl->getText());
+	Result res = datenbank->getResult();
+	unlock();
+	befehl->release();
+	int ret = 0;
+	if (res.zeilenAnzahl > 0)
+		ret = TextZuInt(res.values[0].getText(), 10);
+	res.destroy();
+	return ret;
 }
 
-bool ISDatenbank::adminHatRecht( int id, int recht )
+bool ISDatenbank::adminHatRecht(int id, int recht)
 {
-    Text *befehl = new Text( "SELECT * FROM benutzer_rechte WHERE benutzer_id = " );
-    befehl->append( id );
-    befehl->append( " AND rechte_id = " );
-    befehl->append( recht );
-    lock();
-    datenbank->befehl( befehl->getText() );
-    int ret = datenbank->getZeilenAnzahl();
-    unlock();
-    befehl->release();
-    return ret != 0;
+	Text* befehl = new Text("SELECT * FROM benutzer_rechte WHERE benutzer_id = ");
+	befehl->append(id);
+	befehl->append(" AND rechte_id = ");
+	befehl->append(recht);
+	lock();
+	datenbank->befehl(befehl->getText());
+	int ret = datenbank->getZeilenAnzahl();
+	unlock();
+	befehl->release();
+	return ret != 0;
 }
 
-bool ISDatenbank::proveKlient( int num, int sNum )
+bool ISDatenbank::proveKlient(int num, int sNum)
 {
-    Text *befehl = new Text( "SELECT * FROM server_client WHERE server_id = " );
-    befehl->append( sNum );
-    befehl->append( " AND client_id = " );
-    befehl->append( num );
-    lock();
-    datenbank->befehl( befehl->getText() );
-    Result res = datenbank->getResult();
-    unlock();
-    befehl->release();
-    bool ret = 0;
-    if( res.zeilenAnzahl == 1 )
-        ret = 1;
-    res.destroy();
-    return ret;
+	Text* befehl = new Text("SELECT * FROM server_client WHERE server_id = ");
+	befehl->append(sNum);
+	befehl->append(" AND client_id = ");
+	befehl->append(num);
+	lock();
+	datenbank->befehl(befehl->getText());
+	Result res = datenbank->getResult();
+	unlock();
+	befehl->release();
+	bool ret = 0;
+	if (res.zeilenAnzahl == 1)
+		ret = 1;
+	res.destroy();
+	return ret;
 }
 
-Text *ISDatenbank::getKlientKey( int cId )
+Text* ISDatenbank::getKlientKey(int cId)
 {
-    lock();
-    if( !datenbank->befehl( Text( "SELECT schluessel FROM client WHERE id = " ) += cId ) )
-    {
-        unlock();
-        return 0;
-    }
-    Result res = datenbank->getResult();
-    unlock();
-    if( !res.zeilenAnzahl )
-    {
-        res.destroy();
-        return 0;
-    }
-    Text *ret = new Text( res.values[ 0 ].getText() );
-    res.destroy();
-    return ret;
+	lock();
+	if (!datenbank->befehl(Text("SELECT schluessel FROM client WHERE id = ") += cId))
+	{
+		unlock();
+		return 0;
+	}
+	Result res = datenbank->getResult();
+	unlock();
+	if (!res.zeilenAnzahl)
+	{
+		res.destroy();
+		return 0;
+	}
+	Text* ret = new Text(res.values[0].getText());
+	res.destroy();
+	return ret;
 }
 
-void ISDatenbank::unregisterKlient( int num, int sNum )
+void ISDatenbank::unregisterKlient(int num, int sNum)
 {
-    Text *befehl = new Text( "DELETE FROM server_client WHERE client_id = " );
-    befehl->append( num );
-    befehl->append( " AND server_id = " );
-    befehl->append( sNum );
-    lock();
-    datenbank->befehl( befehl->getText() );
-    int za = datenbank->getZeilenAnzahl();
-    unlock();
-    if( za == 1 )
-    {
-        befehl->setText( "UPDATE server SET tasks = tasks - 1 WHERE id = " );
-        befehl->append( sNum );
-        lock();
-        datenbank->befehl( befehl->getText() );
-        unlock();
-    }
-    befehl->release();
+	Text* befehl = new Text("DELETE FROM server_client WHERE client_id = ");
+	befehl->append(num);
+	befehl->append(" AND server_id = ");
+	befehl->append(sNum);
+	lock();
+	datenbank->befehl(befehl->getText());
+	int za = datenbank->getZeilenAnzahl();
+	unlock();
+	if (za == 1)
+	{
+		befehl->setText("UPDATE server SET tasks = tasks - 1 WHERE id = ");
+		befehl->append(sNum);
+		lock();
+		datenbank->befehl(befehl->getText());
+		unlock();
+	}
+	befehl->release();
 }
 
-bool ISDatenbank::setServerStatus( int id, int status )
+bool ISDatenbank::setServerStatus(int id, int status)
 {
-    Text *befehl = new Text( "UPDATE server SET server_status_id = " );
-    *befehl += status;
-    *befehl += "WHERE id = ";
-    *befehl += id;
-    lock();
-    if( !datenbank->befehl( befehl->getText() ) )
-    {
-        unlock();
-        befehl->release();
-        return 0;
-    }
-    bool ret = datenbank->getZeilenAnzahl() != 0;
-    unlock();
-    befehl->release();
-    return ret;
+	Text* befehl = new Text("UPDATE server SET server_status_id = ");
+	*befehl += status;
+	*befehl += "WHERE id = ";
+	*befehl += id;
+	lock();
+	if (!datenbank->befehl(befehl->getText()))
+	{
+		unlock();
+		befehl->release();
+		return 0;
+	}
+	bool ret = datenbank->getZeilenAnzahl() != 0;
+	unlock();
+	befehl->release();
+	return ret;
 }
 
-bool ISDatenbank::setMaxClients( int id, int maxC )
+bool ISDatenbank::setMaxClients(int id, int maxC)
 {
-    Text *befehl = new Text( "UPDATE server SET max_tasks = " );
-    befehl->append( maxC );
-    befehl->append( " WHERE id = " );
-    befehl->append( id );
-    lock();
-    if( !datenbank->befehl( befehl->getText() ) )
-    {
-        unlock();
-        befehl->release();
-        return 0;
-    }
-    bool ret = datenbank->getZeilenAnzahl() > 0;
-    unlock();
-    befehl->release();
-    return ret;
+	Text* befehl = new Text("UPDATE server SET max_tasks = ");
+	befehl->append(maxC);
+	befehl->append(" WHERE id = ");
+	befehl->append(id);
+	lock();
+	if (!datenbank->befehl(befehl->getText()))
+	{
+		unlock();
+		befehl->release();
+		return 0;
+	}
+	bool ret = datenbank->getZeilenAnzahl() > 0;
+	unlock();
+	befehl->release();
+	return ret;
 }
 
-bool ISDatenbank::serverIstNichtPausiert( int id )
+bool ISDatenbank::serverIstNichtPausiert(int id)
 {
-    Text *befehl = new Text( "SELECT server_status_id FROM server WHERE id = " );
-    befehl->append( id );
-    lock();
-    if( !datenbank->befehl( befehl->getText() ) )
-    {
-        unlock();
-        befehl->release();
-        return 0;
-    }
-    Result res = datenbank->getResult();
-    unlock();
-    befehl->release();
-    if( !res.zeilenAnzahl )
-    {
-        res.destroy();
-        return 0;
-    }
-    bool ret = (int)res.values[ 0 ] == 3;
-    res.destroy();
-    return ret;
+	Text* befehl = new Text("SELECT server_status_id FROM server WHERE id = ");
+	befehl->append(id);
+	lock();
+	if (!datenbank->befehl(befehl->getText()))
+	{
+		unlock();
+		befehl->release();
+		return 0;
+	}
+	Result res = datenbank->getResult();
+	unlock();
+	befehl->release();
+	if (!res.zeilenAnzahl)
+	{
+		res.destroy();
+		return 0;
+	}
+	bool ret = (int)res.values[0] == 3;
+	res.destroy();
+	return ret;
 }
 
-Text *ISDatenbank::getInformationsText( char *typ )
+Text* ISDatenbank::getInformationsText(char* typ)
 {
-    lock();
-    if( !datenbank->befehl( "SELECT text, typ FROM info_text ORDER BY insert_datum DESC LIMIT 1" ) )
-    {
-        unlock();
-        return 0;
-    }
-    Result res = datenbank->getResult();
-    unlock();
-    if( !res.zeilenAnzahl )
-    {
-        res.destroy();
-        *typ = 0;
-        return 0;
-    }
-    *typ = (char)TextZuInt( res.values[ 1 ].getText(), 10 );
-    Text *ret = new Text( res.values[ 0 ].getText() );
-    res.destroy();
-    return ret;
+	lock();
+	if (!datenbank->befehl("SELECT text, typ FROM info_text ORDER BY insert_datum DESC LIMIT 1"))
+	{
+		unlock();
+		return 0;
+	}
+	Result res = datenbank->getResult();
+	unlock();
+	if (!res.zeilenAnzahl)
+	{
+		res.destroy();
+		*typ = 0;
+		return 0;
+	}
+	*typ = (char)TextZuInt(res.values[1].getText(), 10);
+	Text* ret = new Text(res.values[0].getText());
+	res.destroy();
+	return ret;
 }
 
-bool ISDatenbank::istSpielErlaubt( int spielId )
+bool ISDatenbank::istSpielErlaubt(int spielId)
 {
-    Text *befehl = new Text( "SELECT erlaubt FROM spiel_art WHERE id = " );
-    befehl->append( spielId );
-    lock();
-    if( !datenbank->befehl( befehl->getText() ) )
-    {
-        unlock();
-        befehl->release();
-        return 0;
-    }
-    Result res = datenbank->getResult();
-    unlock();
-    befehl->release();
-    bool ret = 0;
-    if( res.zeilenAnzahl > 0 && res.values[ 0 ].istGleich( "t" ) )
-        ret = 1;
-    res.destroy();
-    return ret;
+	Text* befehl = new Text("SELECT erlaubt FROM spiel_art WHERE id = ");
+	befehl->append(spielId);
+	lock();
+	if (!datenbank->befehl(befehl->getText()))
+	{
+		unlock();
+		befehl->release();
+		return 0;
+	}
+	Result res = datenbank->getResult();
+	unlock();
+	befehl->release();
+	bool ret = 0;
+	if (res.zeilenAnzahl > 0 && res.values[0].istGleich("t"))
+		ret = 1;
+	res.destroy();
+	return ret;
 }
 
-bool ISDatenbank::istKarteErlaubt( int karteId )
+bool ISDatenbank::istKarteErlaubt(int karteId)
 {
-    Text *befehl = new Text( "SELECT erlaubt FROM karte WHERE id = " );
-    befehl->append( karteId );
-    lock();
-    if( !datenbank->befehl( befehl->getText() ) )
-    {
-        unlock();
-        befehl->release();
-        return 0;
-    }
-    Result res = datenbank->getResult();
-    unlock();
-    befehl->release();
-    bool ret = 0;
-    if( res.zeilenAnzahl > 0 && res.values[ 0 ].istGleich( "t" ) )
-        ret = 1;
-    res.destroy();
-    return ret;
+	Text* befehl = new Text("SELECT erlaubt FROM karte WHERE id = ");
+	befehl->append(karteId);
+	lock();
+	if (!datenbank->befehl(befehl->getText()))
+	{
+		unlock();
+		befehl->release();
+		return 0;
+	}
+	Result res = datenbank->getResult();
+	unlock();
+	befehl->release();
+	bool ret = 0;
+	if (res.zeilenAnzahl > 0 && res.values[0].istGleich("t"))
+		ret = 1;
+	res.destroy();
+	return ret;
 }
 
-Text *ISDatenbank::getAccountRufName( int accountId )
+Text* ISDatenbank::getAccountRufName(int accountId)
 {
-    Text *befehl = new Text( "SELECT ruf_name FROM account WHERE id = " );
-    befehl->append( accountId );
-    lock();
-    if( !datenbank->befehl( befehl->getText() ) )
-    {
-        unlock();
-        befehl->release();
-        return 0;
-    }
-    Result res = datenbank->getResult();
-    unlock();
-    befehl->release();
-    if( !res.zeilenAnzahl )
-    {
-        res.destroy();
-        return 0;
-    }
-    Text *ret = new Text( res.values[ 0 ].getText() );
-    res.destroy();
-    return ret;
+	Text* befehl = new Text("SELECT ruf_name FROM account WHERE id = ");
+	befehl->append(accountId);
+	lock();
+	if (!datenbank->befehl(befehl->getText()))
+	{
+		unlock();
+		befehl->release();
+		return 0;
+	}
+	Result res = datenbank->getResult();
+	unlock();
+	befehl->release();
+	if (!res.zeilenAnzahl)
+	{
+		res.destroy();
+		return 0;
+	}
+	Text* ret = new Text(res.values[0].getText());
+	res.destroy();
+	return ret;
 }
 
-int ISDatenbank::getAccountId( char *rufName )
+int ISDatenbank::getAccountId(const char* rufName)
 {
-    Text *befehl = new Text( "SELECT id FROM account WHERE ruf_name = '" );
-    befehl->append( rufName );
-    befehl->append( "' LIMIT 1" );
-    lock();
-    if( !datenbank->befehl( befehl->getText() ) )
-    {
-        unlock();
-        befehl->release();
-        return 0;
-    }
-    Result res = datenbank->getResult();
-    unlock();
-    befehl->release();
-    if( !res.zeilenAnzahl )
-    {
-        res.destroy();
-        return 0;
-    }
-    int ret = TextZuInt( res.values[ 0 ].getText(), 10 );
-    res.destroy();
-    return ret;
+	Text* befehl = new Text("SELECT id FROM account WHERE ruf_name = '");
+	befehl->append(rufName);
+	befehl->append("' LIMIT 1");
+	lock();
+	if (!datenbank->befehl(befehl->getText()))
+	{
+		unlock();
+		befehl->release();
+		return 0;
+	}
+	Result res = datenbank->getResult();
+	unlock();
+	befehl->release();
+	if (!res.zeilenAnzahl)
+	{
+		res.destroy();
+		return 0;
+	}
+	int ret = TextZuInt(res.values[0].getText(), 10);
+	res.destroy();
+	return ret;
 }
 
-Array< int > *ISDatenbank::getAccountSpielStatistik( int accountId, int spielId )
+Array< int >* ISDatenbank::getAccountSpielStatistik(int accountId, int spielId)
 {
-    Text *befehl = new Text( "SELECT gespielt, gewonnen, verloren, punkte, bw0, bw1, bw2, bw3, bw4, bw5 FROM spiel_statistik WHERE account_id = " );
-    befehl->append( accountId );
-    befehl->append( " AND spiel_art_id = " );
-    befehl->append( spielId );
-    lock();
-    if( !datenbank->befehl( befehl->getText() ) )
-    {
-        unlock();
-        befehl->release();
-        return 0;
-    }
-    Result res = datenbank->getResult();
-    unlock();
-    befehl->release();
-    Array< int > *ret = new Array< int >();
-    if( !res.zeilenAnzahl )
-    {
-        for( int i = 0; i < res.feldAnzahl; i++ )
-            ret->add( 0 );
-        res.destroy();
-        return ret;
-    }
-    for( int i = 0; i < res.feldAnzahl; i++ )
-        ret->add( TextZuInt( res.values[ i ].getText(), 10 ) );
-    res.destroy();
-    return ret;
+	Text* befehl = new Text("SELECT gespielt, gewonnen, verloren, punkte, bw0, bw1, bw2, bw3, bw4, bw5 FROM spiel_statistik WHERE account_id = ");
+	befehl->append(accountId);
+	befehl->append(" AND spiel_art_id = ");
+	befehl->append(spielId);
+	lock();
+	if (!datenbank->befehl(befehl->getText()))
+	{
+		unlock();
+		befehl->release();
+		return 0;
+	}
+	Result res = datenbank->getResult();
+	unlock();
+	befehl->release();
+	Array< int >* ret = new Array< int >();
+	if (!res.zeilenAnzahl)
+	{
+		for (int i = 0; i < res.feldAnzahl; i++)
+			ret->add(0);
+		res.destroy();
+		return ret;
+	}
+	for (int i = 0; i < res.feldAnzahl; i++)
+		ret->add(TextZuInt(res.values[i].getText(), 10));
+	res.destroy();
+	return ret;
 }
 
-int ISDatenbank::getAccountKarteSpiele( int accountId, int karteId )
+int ISDatenbank::getAccountKarteSpiele(int accountId, int karteId)
 {
-    Text *befehl = new Text( "SELECT count( a.id ) FROM spiel a, spiel_spieler b WHERE a.id = b.spiel_id AND b.account_id = " );
-    befehl->append( accountId );
-    befehl->append( " AND a.karte_id = " );
-    befehl->append( karteId );
-    lock();
-    if( !datenbank->befehl( befehl->getText() ) )
-    {
-        unlock();
-        befehl->release();
-        return 0;
-    }
-    Result res = datenbank->getResult();
-    unlock();
-    befehl->release();
-    if( !res.zeilenAnzahl )
-    {
-        res.destroy();
-        return 0;
-    }
-    int ret = res.values[ 0 ];
-    res.destroy();
-    return ret;
+	Text* befehl = new Text("SELECT count( a.id ) FROM spiel a, spiel_spieler b WHERE a.id = b.spiel_id AND b.account_id = ");
+	befehl->append(accountId);
+	befehl->append(" AND a.karte_id = ");
+	befehl->append(karteId);
+	lock();
+	if (!datenbank->befehl(befehl->getText()))
+	{
+		unlock();
+		befehl->release();
+		return 0;
+	}
+	Result res = datenbank->getResult();
+	unlock();
+	befehl->release();
+	if (!res.zeilenAnzahl)
+	{
+		res.destroy();
+		return 0;
+	}
+	int ret = (int)res.values[0];
+	res.destroy();
+	return ret;
 }
 
-int ISDatenbank::getAccountKarteSpieleGewonnen( int accountId, int karteId )
+int ISDatenbank::getAccountKarteSpieleGewonnen(int accountId, int karteId)
 {
-    Text *befehl = new Text( "SELECT count( a.id ) FROM spiel a, spiel_spieler b WHERE a.id = b.spiel_id "
-                             "AND b.spiel_spieler_status_id = 2 AND b.account_id = " );
-    befehl->append( accountId );
-    befehl->append( " AND a.karte_id = " );
-    befehl->append( karteId );
-    lock();
-    if( !datenbank->befehl( befehl->getText() ) )
-    {
-        unlock();
-        befehl->release();
-        return 0;
-    }
-    Result res = datenbank->getResult();
-    unlock();
-    befehl->release();
-    if( !res.zeilenAnzahl )
-    {
-        res.destroy();
-        return 0;
-    }
-    int ret = res.values[ 0 ];
-    res.destroy();
-    return ret;
+	Text* befehl = new Text("SELECT count( a.id ) FROM spiel a, spiel_spieler b WHERE a.id = b.spiel_id "
+		"AND b.spiel_spieler_status_id = 2 AND b.account_id = ");
+	befehl->append(accountId);
+	befehl->append(" AND a.karte_id = ");
+	befehl->append(karteId);
+	lock();
+	if (!datenbank->befehl(befehl->getText()))
+	{
+		unlock();
+		befehl->release();
+		return 0;
+	}
+	Result res = datenbank->getResult();
+	unlock();
+	befehl->release();
+	if (!res.zeilenAnzahl)
+	{
+		res.destroy();
+		return 0;
+	}
+	int ret = (int)res.values[0];
+	res.destroy();
+	return ret;
 }
 
-Text *ISDatenbank::getKarteName( int karteId )
+Text* ISDatenbank::getKarteName(int karteId)
 {
-    Text *befehl = new Text( "SELECT name FROM karte WHERE id = " );
-    befehl->append( karteId );
-    lock();
-    if( !datenbank->befehl( befehl->getText() ) )
-    {
-        unlock();
-        befehl->release();
-        return 0;
-    }
-    Result res = datenbank->getResult();
-    unlock();
-    befehl->release();
-    if( !res.zeilenAnzahl )
-    {
-        res.destroy();
-        return 0;
-    }
-    Text *ret = new Text( res.values[ 0 ].getText() );
-    res.destroy();
-    return ret;
+	Text* befehl = new Text("SELECT name FROM karte WHERE id = ");
+	befehl->append(karteId);
+	lock();
+	if (!datenbank->befehl(befehl->getText()))
+	{
+		unlock();
+		befehl->release();
+		return 0;
+	}
+	Result res = datenbank->getResult();
+	unlock();
+	befehl->release();
+	if (!res.zeilenAnzahl)
+	{
+		res.destroy();
+		return 0;
+	}
+	Text* ret = new Text(res.values[0].getText());
+	res.destroy();
+	return ret;
 }
 
-Text *ISDatenbank::getSpielName( int spielId )
+Text* ISDatenbank::getSpielName(int spielId)
 {
-    Text *befehl = new Text( "SELECT name FROM spiel_art WHERE id = " );
-    befehl->append( spielId );
-    lock();
-    if( !datenbank->befehl( befehl->getText() ) )
-    {
-        unlock();
-        befehl->release();
-        return 0;
-    }
-    Result res = datenbank->getResult();
-    unlock();
-    befehl->release();
-    if( !res.zeilenAnzahl )
-    {
-        res.destroy();
-        return 0;
-    }
-    Text *ret = new Text( res.values[ 0 ].getText() );
-    res.destroy();
-    return ret;
+	Text* befehl = new Text("SELECT name FROM spiel_art WHERE id = ");
+	befehl->append(spielId);
+	lock();
+	if (!datenbank->befehl(befehl->getText()))
+	{
+		unlock();
+		befehl->release();
+		return 0;
+	}
+	Result res = datenbank->getResult();
+	unlock();
+	befehl->release();
+	if (!res.zeilenAnzahl)
+	{
+		res.destroy();
+		return 0;
+	}
+	Text* ret = new Text(res.values[0].getText());
+	res.destroy();
+	return ret;
 }
 
-Text *ISDatenbank::getChatroomName( int chatroomId )
+Text* ISDatenbank::getChatroomName(int chatroomId)
 {
-    Text *befehl = new Text( "SELECT name FROM chatroom WHERE id = " );
-    befehl->append( chatroomId );
-    lock();
-    if( !datenbank->befehl( befehl->getText() ) )
-    {
-        unlock();
-        befehl->release();
-        return 0;
-    }
-    Result res = datenbank->getResult();
-    unlock();
-    befehl->release();
-    if( !res.zeilenAnzahl )
-    {
-        res.destroy();
-        return 0;
-    }
-    Text *ret = new Text( res.values[ 0 ].getText() );
-    res.destroy();
-    return ret;
+	Text* befehl = new Text("SELECT name FROM chatroom WHERE id = ");
+	befehl->append(chatroomId);
+	lock();
+	if (!datenbank->befehl(befehl->getText()))
+	{
+		unlock();
+		befehl->release();
+		return 0;
+	}
+	Result res = datenbank->getResult();
+	unlock();
+	befehl->release();
+	if (!res.zeilenAnzahl)
+	{
+		res.destroy();
+		return 0;
+	}
+	Text* ret = new Text(res.values[0].getText());
+	res.destroy();
+	return ret;
 }
 
-int ISDatenbank::getChatroomId( char *name )
+int ISDatenbank::getChatroomId(const char* name)
 {
-    Text *befehl = new Text( "SELECT id FROM chatroom WHERE name = '" );
-    befehl->append( name );
-    befehl->append( "' LIMIT 1" );
-    lock();
-    if( !datenbank->befehl( befehl->getText() ) )
-    {
-        unlock();
-        befehl->release();
-        return 0;
-    }
-    Result res = datenbank->getResult();
-    unlock();
-    befehl->release();
-    if( !res.zeilenAnzahl )
-    {
-        res.destroy();
-        return 0;
-    }
-    int ret = TextZuInt( res.values[ 0 ].getText(), 10 );
-    res.destroy();
-    return ret;
+	Text* befehl = new Text("SELECT id FROM chatroom WHERE name = '");
+	befehl->append(name);
+	befehl->append("' LIMIT 1");
+	lock();
+	if (!datenbank->befehl(befehl->getText()))
+	{
+		unlock();
+		befehl->release();
+		return 0;
+	}
+	Result res = datenbank->getResult();
+	unlock();
+	befehl->release();
+	if (!res.zeilenAnzahl)
+	{
+		res.destroy();
+		return 0;
+	}
+	int ret = TextZuInt(res.values[0].getText(), 10);
+	res.destroy();
+	return ret;
 }
 
-int ISDatenbank::getSpielId( int karteId )
+int ISDatenbank::getSpielId(int karteId)
 {
-    Text *befehl = new Text( "SELECT spiel_art_id FROM karte WHERE id = " );
-    befehl->append( karteId );
-    lock();
-    if( !datenbank->befehl( befehl->getText() ) )
-    {
-        unlock();
-        befehl->release();
-        return 0;
-    }
-    Result res = datenbank->getResult();
-    unlock();
-    befehl->release();
-    if( !res.zeilenAnzahl )
-    {
-        res.destroy();
-        return 0;
-    }
-    int ret = TextZuInt( res.values[ 0 ].getText(), 10 );
-    res.destroy();
-    return ret;
+	Text* befehl = new Text("SELECT spiel_art_id FROM karte WHERE id = ");
+	befehl->append(karteId);
+	lock();
+	if (!datenbank->befehl(befehl->getText()))
+	{
+		unlock();
+		befehl->release();
+		return 0;
+	}
+	Result res = datenbank->getResult();
+	unlock();
+	befehl->release();
+	if (!res.zeilenAnzahl)
+	{
+		res.destroy();
+		return 0;
+	}
+	int ret = TextZuInt(res.values[0].getText(), 10);
+	res.destroy();
+	return ret;
 }
 
-int ISDatenbank::getSpielId( char *name )
+int ISDatenbank::getSpielId(const char* name)
 {
-    Text *befehl = new Text( "SELECT id FROM spiel_art WHERE name = '" );
-    befehl->append( name );
-    befehl->append( "'" );
-    lock();
-    if( !datenbank->befehl( befehl->getText() ) )
-    {
-        unlock();
-        befehl->release();
-        return 0;
-    }
-    Result res = datenbank->getResult();
-    unlock();
-    befehl->release();
-    if( !res.zeilenAnzahl )
-    {
-        res.destroy();
-        return 0;
-    }
-    int ret = TextZuInt( res.values[ 0 ].getText(), 10 );
-    res.destroy();
-    return ret;
+	Text* befehl = new Text("SELECT id FROM spiel_art WHERE name = '");
+	befehl->append(name);
+	befehl->append("'");
+	lock();
+	if (!datenbank->befehl(befehl->getText()))
+	{
+		unlock();
+		befehl->release();
+		return 0;
+	}
+	Result res = datenbank->getResult();
+	unlock();
+	befehl->release();
+	if (!res.zeilenAnzahl)
+	{
+		res.destroy();
+		return 0;
+	}
+	int ret = TextZuInt(res.values[0].getText(), 10);
+	res.destroy();
+	return ret;
 }
 
-int ISDatenbank::getKarteId( char *name )
+int ISDatenbank::getKarteId(const char* name)
 {
-    Text *befehl = new Text( "SELECT id FROM karte WHERE name = '" );
-    befehl->append( name );
-    befehl->append( "'" );
-    lock();
-    if( !datenbank->befehl( befehl->getText() ) )
-    {
-        unlock();
-        befehl->release();
-        return 0;
-    }
-    Result res = datenbank->getResult();
-    unlock();
-    befehl->release();
-    if( !res.zeilenAnzahl )
-    {
-        res.destroy();
-        return 0;
-    }
-    int ret = TextZuInt( res.values[ 0 ].getText(), 10 );
-    res.destroy();
-    return ret;
+	Text* befehl = new Text("SELECT id FROM karte WHERE name = '");
+	befehl->append(name);
+	befehl->append("'");
+	lock();
+	if (!datenbank->befehl(befehl->getText()))
+	{
+		unlock();
+		befehl->release();
+		return 0;
+	}
+	Result res = datenbank->getResult();
+	unlock();
+	befehl->release();
+	if (!res.zeilenAnzahl)
+	{
+		res.destroy();
+		return 0;
+	}
+	int ret = TextZuInt(res.values[0].getText(), 10);
+	res.destroy();
+	return ret;
 }
 
-int ISDatenbank::getGruppenKarteId( int gruppeId )
+int ISDatenbank::getGruppenKarteId(int gruppeId)
 {
-    Text *befehl = new Text( "SELECT karte_id FROM gruppe WHERE id = " );
-    befehl->append( gruppeId );
-    lock();
-    if( !datenbank->befehl( befehl->getText() ) )
-    {
-        unlock();
-        befehl->release();
-        return 0;
-    }
-    Result res = datenbank->getResult();
-    unlock();
-    befehl->release();
-    if( !res.zeilenAnzahl )
-    {
-        res.destroy();
-        return 0;
-    }
-    int ret = TextZuInt( res.values[ 0 ].getText(), 10 );
-    res.destroy();
-    return ret;
+	Text* befehl = new Text("SELECT karte_id FROM gruppe WHERE id = ");
+	befehl->append(gruppeId);
+	lock();
+	if (!datenbank->befehl(befehl->getText()))
+	{
+		unlock();
+		befehl->release();
+		return 0;
+	}
+	Result res = datenbank->getResult();
+	unlock();
+	befehl->release();
+	if (!res.zeilenAnzahl)
+	{
+		res.destroy();
+		return 0;
+	}
+	int ret = TextZuInt(res.values[0].getText(), 10);
+	res.destroy();
+	return ret;
 }
 
-int ISDatenbank::getGruppeAdminId( int gruppeId )
+int ISDatenbank::getGruppeAdminId(int gruppeId)
 {
-    Text *befehl = new Text( "SELECT admin_account_id FROM gruppe WHERE id = " );
-    befehl->append( gruppeId );
-    lock();
-    if( !datenbank->befehl( befehl->getText() ) )
-    {
-        unlock();
-        befehl->release();
-        return 0;
-    }
-    Result res = datenbank->getResult();
-    unlock();
-    befehl->release();
-    if( !res.zeilenAnzahl )
-    {
-        res.destroy();
-        return 0;
-    }
-    int ret = TextZuInt( res.values[ 0 ].getText(), 10 );
-    res.destroy();
-    return ret;
+	Text* befehl = new Text("SELECT admin_account_id FROM gruppe WHERE id = ");
+	befehl->append(gruppeId);
+	lock();
+	if (!datenbank->befehl(befehl->getText()))
+	{
+		unlock();
+		befehl->release();
+		return 0;
+	}
+	Result res = datenbank->getResult();
+	unlock();
+	befehl->release();
+	if (!res.zeilenAnzahl)
+	{
+		res.destroy();
+		return 0;
+	}
+	int ret = TextZuInt(res.values[0].getText(), 10);
+	res.destroy();
+	return ret;
 }
 
-int ISDatenbank::getSpielerPunkte( int spielId, int accountId )
+int ISDatenbank::getSpielerPunkte(int spielId, int accountId)
 {
-    Text *befehl = new Text( "SELECT sum( b.punkte ) FROM spiel a, spiel_spieler b, karte c WHERE a.karte_id = c.id "
-                             "AND a.spiel_status_id = 5 AND c.spiel_art_id = " );
-    befehl->append( spielId );
-    befehl->append( " AND b.spiel_id = a.id AND b.account_id = " );
-    befehl->append( accountId );
-    lock();
-    if( !datenbank->befehl( befehl->getText() ) )
-    {
-        unlock();
-        befehl->release();
-        return 0;
-    }
-    Result res = datenbank->getResult();
-    unlock();
-    befehl->release();
-    if( !res.zeilenAnzahl )
-    {
-        res.destroy();
-        return 0;
-    }
-    int ret = TextZuInt( res.values[ 0 ].getText(), 10 );
-    res.destroy();
-    return ret;
+	Text* befehl = new Text("SELECT sum( b.punkte ) FROM spiel a, spiel_spieler b, karte c WHERE a.karte_id = c.id "
+		"AND a.spiel_status_id = 5 AND c.spiel_art_id = ");
+	befehl->append(spielId);
+	befehl->append(" AND b.spiel_id = a.id AND b.account_id = ");
+	befehl->append(accountId);
+	lock();
+	if (!datenbank->befehl(befehl->getText()))
+	{
+		unlock();
+		befehl->release();
+		return 0;
+	}
+	Result res = datenbank->getResult();
+	unlock();
+	befehl->release();
+	if (!res.zeilenAnzahl)
+	{
+		res.destroy();
+		return 0;
+	}
+	int ret = TextZuInt(res.values[0].getText(), 10);
+	res.destroy();
+	return ret;
 }
 
-Array< int > *ISDatenbank::getAccountSpielArtListe( int cId )
+Array< int >* ISDatenbank::getAccountSpielArtListe(int cId)
 {
-    Text *befehl = new Text( "SELECT a.spiel_art_id FROM spiel_art_account a, account_client b "
-                             "WHERE a.account_id = b.account_id AND a.end_dat IS NULL AND b.client_id = " );
-    befehl->append( cId );
-    lock();
-    if( !datenbank->befehl( befehl->getText() ) )
-    {
-        unlock();
-        befehl->release();
-        return 0;
-    }
-    Result res = datenbank->getResult();
-    unlock();
-    befehl->release();
-    Array< int > *ret = new Array< int >();
-    for( int i = 0; i < res.zeilenAnzahl; i++ )
-        ret->add( TextZuInt( res.values[ i ].getText(), 10 ) );
-    res.destroy();
-    return ret;
+	Text* befehl = new Text("SELECT a.spiel_art_id FROM spiel_art_account a, account_client b "
+		"WHERE a.account_id = b.account_id AND a.end_dat IS NULL AND b.client_id = ");
+	befehl->append(cId);
+	lock();
+	if (!datenbank->befehl(befehl->getText()))
+	{
+		unlock();
+		befehl->release();
+		return 0;
+	}
+	Result res = datenbank->getResult();
+	unlock();
+	befehl->release();
+	Array< int >* ret = new Array< int >();
+	for (int i = 0; i < res.zeilenAnzahl; i++)
+		ret->add(TextZuInt(res.values[i].getText(), 10));
+	res.destroy();
+	return ret;
 }
 
-int ISDatenbank::getNeusteSpielVersion( int sId )
+int ISDatenbank::getNeusteSpielVersion(int sId)
 {
-    Text *befehl = new Text( "SELECT a.version FROM datei_gruppe a, spiel_art b WHERE a.id = b.datei_gruppe_id AND b.id = " );
-    befehl->append( sId );
-    lock();
-    if( !datenbank->befehl( befehl->getText() ) )
-    {
-        unlock();
-        befehl->release();
-        return 0;
-    }
-    Result res = datenbank->getResult();
-    unlock();
-    befehl->release();
-    if( !res.zeilenAnzahl )
-    {
-        res.destroy();
-        return 0;
-    }
-    int ret = TextZuInt( res.values[ 0 ].getText(), 10 );
-    res.destroy();
-    return ret;
+	Text* befehl = new Text("SELECT a.version FROM datei_gruppe a, spiel_art b WHERE a.id = b.datei_gruppe_id AND b.id = ");
+	befehl->append(sId);
+	lock();
+	if (!datenbank->befehl(befehl->getText()))
+	{
+		unlock();
+		befehl->release();
+		return 0;
+	}
+	Result res = datenbank->getResult();
+	unlock();
+	befehl->release();
+	if (!res.zeilenAnzahl)
+	{
+		res.destroy();
+		return 0;
+	}
+	int ret = TextZuInt(res.values[0].getText(), 10);
+	res.destroy();
+	return ret;
 }
 
-int ISDatenbank::getKupfer( int cId )
+int ISDatenbank::getKupfer(int cId)
 {
-    Text *befehl = new Text( "SELECT a.kupfer FROM account a, account_client b WHERE a.id = b.account_id AND b.client_id = " );
-    befehl->append( cId );
-    lock();
-    if( !datenbank->befehl( befehl->getText() ) )
-    {
-        unlock();
-        befehl->release();
-        return 0;
-    }
-    Result res = datenbank->getResult();
-    unlock();
-    befehl->release();
-    if( !res.zeilenAnzahl )
-    {
-        res.destroy();
-        return 0;
-    }
-    int ret = TextZuInt( res.values[ 0 ].getText(), 10 );
-    res.destroy();
-    return ret;
+	Text* befehl = new Text("SELECT a.kupfer FROM account a, account_client b WHERE a.id = b.account_id AND b.client_id = ");
+	befehl->append(cId);
+	lock();
+	if (!datenbank->befehl(befehl->getText()))
+	{
+		unlock();
+		befehl->release();
+		return 0;
+	}
+	Result res = datenbank->getResult();
+	unlock();
+	befehl->release();
+	if (!res.zeilenAnzahl)
+	{
+		res.destroy();
+		return 0;
+	}
+	int ret = TextZuInt(res.values[0].getText(), 10);
+	res.destroy();
+	return ret;
 }
 
-int ISDatenbank::getDateiGruppeVonSpiel( int sId )
+int ISDatenbank::getDateiGruppeVonSpiel(int sId)
 {
-    Text *befehl = new Text( "SELECT datei_gruppe_id FROM spiel_art WHERE id = " );
-    befehl->append( sId );
-    lock();
-    if( !datenbank->befehl( befehl->getText() ) )
-    {
-        unlock();
-        befehl->release();
-        return 0;
-    }
-    Result res = datenbank->getResult();
-    unlock();
-    befehl->release();
-    if( !res.zeilenAnzahl )
-    {
-        res.destroy();
-        return 0;
-    }
-    int ret = TextZuInt( res.values[ 0 ].getText(), 10 );
-    res.destroy();
-    return ret;
+	Text* befehl = new Text("SELECT datei_gruppe_id FROM spiel_art WHERE id = ");
+	befehl->append(sId);
+	lock();
+	if (!datenbank->befehl(befehl->getText()))
+	{
+		unlock();
+		befehl->release();
+		return 0;
+	}
+	Result res = datenbank->getResult();
+	unlock();
+	befehl->release();
+	if (!res.zeilenAnzahl)
+	{
+		res.destroy();
+		return 0;
+	}
+	int ret = TextZuInt(res.values[0].getText(), 10);
+	res.destroy();
+	return ret;
 }
 
-Text *ISDatenbank::getDateiGruppePfad( int dgId )
+Text* ISDatenbank::getDateiGruppePfad(int dgId)
 {
-    Text *befehl = new Text( "SELECT pfad FROM datei_gruppe WHERE id = " );
-    befehl->append( dgId );
-    lock();
-    if( !datenbank->befehl( befehl->getText() ) )
-    {
-        unlock();
-        befehl->release();
-        return 0;
-    }
-    Result res = datenbank->getResult();
-    unlock();
-    befehl->release();
-    if( !res.zeilenAnzahl )
-    {
-        res.destroy();
-        return 0;
-    }
-    Text *ret = new Text( res.values[ 0 ].getText() );
-    res.destroy();
-    return ret;
+	Text* befehl = new Text("SELECT pfad FROM datei_gruppe WHERE id = ");
+	befehl->append(dgId);
+	lock();
+	if (!datenbank->befehl(befehl->getText()))
+	{
+		unlock();
+		befehl->release();
+		return 0;
+	}
+	Result res = datenbank->getResult();
+	unlock();
+	befehl->release();
+	if (!res.zeilenAnzahl)
+	{
+		res.destroy();
+		return 0;
+	}
+	Text* ret = new Text(res.values[0].getText());
+	res.destroy();
+	return ret;
 }
 
-Array< int > *ISDatenbank::getAccountKarteListe( int cId, int sId )
+Array< int >* ISDatenbank::getAccountKarteListe(int cId, int sId)
 {
-    Text *befehl = new Text( "SELECT a.karte_id FROM karte_account a, account_client b, karte c "
-                             "WHERE c.id = a.karte_id AND a.account_id = b.account_id AND a.end_dat IS NULL AND b.client_id = " );
-    befehl->append( cId );
-    befehl->append( " AND c.spiel_art_id = " );
-    befehl->append( sId );
-    lock();
-    if( !datenbank->befehl( befehl->getText() ) )
-    {
-        unlock();
-        befehl->release();
-        return 0;
-    }
-    Result res = datenbank->getResult();
-    unlock();
-    befehl->release();
-    Array< int > *ret = new Array< int >();
-    for( int i = 0; i < res.zeilenAnzahl; i++ )
-        ret->add( TextZuInt( res.values[ i ].getText(), 10 ) );
-    res.destroy();
-    return ret;
+	Text* befehl = new Text("SELECT a.karte_id FROM karte_account a, account_client b, karte c "
+		"WHERE c.id = a.karte_id AND a.account_id = b.account_id AND a.end_dat IS NULL AND b.client_id = ");
+	befehl->append(cId);
+	befehl->append(" AND c.spiel_art_id = ");
+	befehl->append(sId);
+	lock();
+	if (!datenbank->befehl(befehl->getText()))
+	{
+		unlock();
+		befehl->release();
+		return 0;
+	}
+	Result res = datenbank->getResult();
+	unlock();
+	befehl->release();
+	Array< int >* ret = new Array< int >();
+	for (int i = 0; i < res.zeilenAnzahl; i++)
+		ret->add(TextZuInt(res.values[i].getText(), 10));
+	res.destroy();
+	return ret;
 }
 
-bool ISDatenbank::hatAccountKarte( int account, int karte )
+bool ISDatenbank::hatAccountKarte(int account, int karte)
 {
-    Text *befehl = new Text( "SELECT karte_id FROM karte_account WHERE end_dat IS NULL AND karte_id = " );
-    befehl->append( karte );
-    befehl->append( " AND account_id = " );
-    befehl->append( account );
-    lock();
-    if( !datenbank->befehl( befehl->getText() ) )
-    {
-        unlock();
-        befehl->release();
-        return 0;
-    }
-    bool ret = datenbank->getZeilenAnzahl() != 0;
-    unlock();
-    befehl->release();
-    return ret;
+	Text* befehl = new Text("SELECT karte_id FROM karte_account WHERE end_dat IS NULL AND karte_id = ");
+	befehl->append(karte);
+	befehl->append(" AND account_id = ");
+	befehl->append(account);
+	lock();
+	if (!datenbank->befehl(befehl->getText()))
+	{
+		unlock();
+		befehl->release();
+		return 0;
+	}
+	bool ret = datenbank->getZeilenAnzahl() != 0;
+	unlock();
+	befehl->release();
+	return ret;
 }
 
-bool ISDatenbank::hatAccountSpiel( int account, int spiel )
+bool ISDatenbank::hatAccountSpiel(int account, int spiel)
 {
-    Text *befehl = new Text( "SELECT spiel_art_id FROM spiel_art_account WHERE end_dat IS NULL AND spiel_art_id = " );
-    befehl->append( spiel );
-    befehl->append( " AND account_id = " );
-    befehl->append( account );
-    lock();
-    if( !datenbank->befehl( befehl->getText() ) )
-    {
-        unlock();
-        befehl->release();
-        return 0;
-    }
-    bool ret = datenbank->getZeilenAnzahl() != 0;
-    unlock();
-    befehl->release();
-    return ret;
+	Text* befehl = new Text("SELECT spiel_art_id FROM spiel_art_account WHERE end_dat IS NULL AND spiel_art_id = ");
+	befehl->append(spiel);
+	befehl->append(" AND account_id = ");
+	befehl->append(account);
+	lock();
+	if (!datenbank->befehl(befehl->getText()))
+	{
+		unlock();
+		befehl->release();
+		return 0;
+	}
+	bool ret = datenbank->getZeilenAnzahl() != 0;
+	unlock();
+	befehl->release();
+	return ret;
 }
 
-Array< int > *ISDatenbank::getAccountKarteGespieltListe( int accountId, int spielArt )
+Array< int >* ISDatenbank::getAccountKarteGespieltListe(int accountId, int spielArt)
 {
-    Text *befehl = new Text( "SELECT distinct( c.id ) FROM spiel a, spiel_spieler b, karte c WHERE "
-                             "a.karte_id = c.id AND b.spiel_id = a.id AND b.account_id = " );
-    befehl->append( accountId );
-    befehl->append( " AND c.spiel_art_id = " );
-    befehl->append( spielArt );
-    lock();
-    if( !datenbank->befehl( befehl->getText() ) )
-    {
-        unlock();
-        befehl->release();
-        return 0;
-    }
-    Result res = datenbank->getResult();
-    unlock();
-    befehl->release();
-    Array< int > *ret = new Array< int >();
-    for( int i = 0; i < res.zeilenAnzahl; i++ )
-        ret->set( res.values[ i ], i );
-    res.destroy();
-    return ret;
+	Text* befehl = new Text("SELECT distinct( c.id ) FROM spiel a, spiel_spieler b, karte c WHERE "
+		"a.karte_id = c.id AND b.spiel_id = a.id AND b.account_id = ");
+	befehl->append(accountId);
+	befehl->append(" AND c.spiel_art_id = ");
+	befehl->append(spielArt);
+	lock();
+	if (!datenbank->befehl(befehl->getText()))
+	{
+		unlock();
+		befehl->release();
+		return 0;
+	}
+	Result res = datenbank->getResult();
+	unlock();
+	befehl->release();
+	Array< int >* ret = new Array< int >();
+	for (int i = 0; i < res.zeilenAnzahl; i++)
+		ret->set((int)res.values[i], i);
+	res.destroy();
+	return ret;
 }
 
-Array< int > *ISDatenbank::getAccountSpielGespieltListe( int accountId )
+Array< int >* ISDatenbank::getAccountSpielGespieltListe(int accountId)
 {
-    Text *befehl = new Text( "SELECT distinct( c.spiel_art_id ) FROM spiel a, spiel_spieler b, karte c WHERE "
-                             "a.karte_id = c.id AND b.spiel_id = a.id AND b.account_id = " );
-    befehl->append( accountId );
-    lock();
-    if( !datenbank->befehl( befehl->getText() ) )
-    {
-        unlock();
-        befehl->release();
-        return 0;
-    }
-    Result res = datenbank->getResult();
-    unlock();
-    befehl->release();
-    Array< int > *ret = new Array< int >();
-    for( int i = 0; i < res.zeilenAnzahl; i++ )
-        ret->add( res.values[ i ] );
-    res.destroy();
-    return ret;
+	Text* befehl = new Text("SELECT distinct( c.spiel_art_id ) FROM spiel a, spiel_spieler b, karte c WHERE "
+		"a.karte_id = c.id AND b.spiel_id = a.id AND b.account_id = ");
+	befehl->append(accountId);
+	lock();
+	if (!datenbank->befehl(befehl->getText()))
+	{
+		unlock();
+		befehl->release();
+		return 0;
+	}
+	Result res = datenbank->getResult();
+	unlock();
+	befehl->release();
+	Array< int >* ret = new Array< int >();
+	for (int i = 0; i < res.zeilenAnzahl; i++)
+		ret->add((int)res.values[i]);
+	res.destroy();
+	return ret;
 }
 
-int ISDatenbank::getDateiGruppeVonPfad( char *pfad )
+int ISDatenbank::getDateiGruppeVonPfad(const char* pfad)
 {
-    Text *befehl = new Text( "SELECT id FROM datei_gruppe WHERE pfad = '" );
-    befehl->append( pfad );
-    befehl->append( "'" );
-    lock();
-    if( !datenbank->befehl( befehl->getText() ) )
-    {
-        unlock();
-        befehl->release();
-        return 0;
-    }
-    Result res = datenbank->getResult();
-    unlock();
-    befehl->release();
-    if( !res.zeilenAnzahl )
-    {
-        res.destroy();
-        return 0;
-    }
-    int ret = TextZuInt( res.values[ 0 ].getText(), 10 );
-    res.destroy();
-    return ret;
+	Text* befehl = new Text("SELECT id FROM datei_gruppe WHERE pfad = '");
+	befehl->append(pfad);
+	befehl->append("'");
+	lock();
+	if (!datenbank->befehl(befehl->getText()))
+	{
+		unlock();
+		befehl->release();
+		return 0;
+	}
+	Result res = datenbank->getResult();
+	unlock();
+	befehl->release();
+	if (!res.zeilenAnzahl)
+	{
+		res.destroy();
+		return 0;
+	}
+	int ret = TextZuInt(res.values[0].getText(), 10);
+	res.destroy();
+	return ret;
 }
 
-int ISDatenbank::getNeusteDateiGruppe( int dg )
+int ISDatenbank::getNeusteDateiGruppe(int dg)
 {
-    Text *befehl = new Text( "SELECT version FROM datei_gruppe WHERE id = " );
-    befehl->append( dg );
-    lock();
-    if( !datenbank->befehl( befehl->getText() ) )
-    {
-        unlock();
-        befehl->release();
-        return 0;
-    }
-    Result res = datenbank->getResult();
-    unlock();
-    befehl->release();
-    if( !res.zeilenAnzahl )
-    {
-        res.destroy();
-        return 0;
-    }
-    int ret = TextZuInt( res.values[ 0 ].getText(), 10 );
-    res.destroy();
-    return ret;
+	Text* befehl = new Text("SELECT version FROM datei_gruppe WHERE id = ");
+	befehl->append(dg);
+	lock();
+	if (!datenbank->befehl(befehl->getText()))
+	{
+		unlock();
+		befehl->release();
+		return 0;
+	}
+	Result res = datenbank->getResult();
+	unlock();
+	befehl->release();
+	if (!res.zeilenAnzahl)
+	{
+		res.destroy();
+		return 0;
+	}
+	int ret = TextZuInt(res.values[0].getText(), 10);
+	res.destroy();
+	return ret;
 }
 
-bool ISDatenbank::getGruppeSpielerAdd( int gruppeId )
+bool ISDatenbank::getGruppeSpielerAdd(int gruppeId)
 {
-    Text *befehl = new Text( "SELECT spiel_starten FROM gruppe WHERE id = " );
-    befehl->append( gruppeId );
-    lock();
-    if( !datenbank->befehl( befehl->getText() ) )
-    {
-        unlock();
-        befehl->release();
-        return 0;
-    }
-    Result res = datenbank->getResult();
-    unlock();
-    befehl->release();
-    if( !res.zeilenAnzahl )
-    {
-        res.destroy();
-        return 0;
-    }
-    bool ret = res.values[ 0 ].istGleich( "f" );
-    res.destroy();
-    return ret;
+	Text* befehl = new Text("SELECT spiel_starten FROM gruppe WHERE id = ");
+	befehl->append(gruppeId);
+	lock();
+	if (!datenbank->befehl(befehl->getText()))
+	{
+		unlock();
+		befehl->release();
+		return 0;
+	}
+	Result res = datenbank->getResult();
+	unlock();
+	befehl->release();
+	if (!res.zeilenAnzahl)
+	{
+		res.destroy();
+		return 0;
+	}
+	bool ret = res.values[0].istGleich("f");
+	res.destroy();
+	return ret;
 }
 
-Result ISDatenbank::getSpielerListe( char *suche, int *seite, int *maxSeite, int sortStalte, bool backwords )
+Result ISDatenbank::getSpielerListe(const char* suche, int* seite, int* maxSeite, int sortStalte, bool backwords)
 {
-    Text *befehl = new Text( "SELECT count( a.id ) FROM account a, "
-                             "( SELECT a.id, max( b.datum ) "
-                             "  FROM account a LEFT JOIN "
-                             "  ( SELECT g.spiel_art_id, i.account_id"
-                             "    FROM karte g, spiel h, spiel_spieler i "
-                             "    WHERE i.spiel_id = h.id AND h.karte_id = g.id AND h.beginn_datum = "
-                             "   ( SELECT max( x.beginn_datum ) FROM spiel x, spiel_spieler y WHERE y.spiel_id = x.id AND y.account_id = i.account_id ) ) f ON a.id = f.account_id "
-                             "  LEFT JOIN account_online b ON b.account_id = a.id "
-                             "  LEFT JOIN spiel_statistik e ON e.account_id = a.id "
-                             "  LEFT JOIN spiel_art c ON c.id = f.spiel_art_id "
-                             "  LEFT JOIN karte d ON c.id = d.spiel_art_id "
-                             "  WHERE a.name LIKE '" );
-    befehl->append( suche );
-    befehl->append( "' AND d.spiel_art_id = c.id "
-                    "  AND e.spiel_art_id = f.spiel_art_id "
-                    "  GROUP BY a.id ) b "
-                    "WHERE a.id = b.id" );
-    lock();
-    if( !datenbank->befehl( *befehl ) )
-    {
-        unlock();
-        befehl->release();
-        Result res = { 0, 0, 0, 0 };
-        return res;
-    }
-    Result res = datenbank->getResult();
-    unlock();
-    if( !res.zeilenAnzahl )
-    {
-        res.destroy();
-        befehl->release();
-        Result res = { 0, 0, 0, 0 };
-        return res;
-    }
-    int entrys = res.values[ 0 ];
-    res.destroy();
-    *maxSeite = entrys / 21;
-    if( entrys % 21 )
-        ( *maxSeite )++;
-    if( *seite > *maxSeite )
-        *seite = *maxSeite;
-    if( !( *seite ) )
-    {
-        befehl->release();
-        Result res = { 0, 0, 0, 0 };
-        return res;
-    }
-    befehl->setText( "SELECT a.id, a.ruf_name, max( b.datum ), c.name, d.name, e.punkte "
-                     "FROM account a LEFT JOIN "
-                     "( SELECT g.spiel_art_id, i.account_id "
-                     "  FROM karte g, spiel h, spiel_spieler i "
-                     "  WHERE i.spiel_id = h.id AND h.karte_id = g.id AND h.beginn_datum = "
-                     "( SELECT max( x.beginn_datum ) FROM spiel x, spiel_spieler y WHERE y.spiel_id = x.id AND y.account_id = i.account_id ) ) f ON a.id = f.account_id "
-                     "LEFT JOIN account_online b ON b.account_id = a.id "
-                     "LEFT JOIN spiel_statistik e ON e.account_id = a.id "
-                     "LEFT JOIN spiel_art c ON c.id = f.spiel_art_id "
-                     "LEFT JOIN karte d ON c.id = d.spiel_art_id "
-                     "WHERE a.name LIKE '" );
-    befehl->append( suche );
-    befehl->append( "' AND ( d.spiel_art_id = c.id "
-                    "AND e.spiel_art_id = f.spiel_art_id ) "
-                    "OR d.spiel_art_id IS NULL "
-                    "GROUP BY a.id, a.ruf_name, c.name, d.name, e.punkte ORDER BY " );
-    befehl->append( sortStalte + 2 );
-    if( backwords )
-        befehl->append( " DESC" );
-    befehl->append( " OFFSET " );
-    befehl->append( ( ( *seite ) - 1 ) * 21 );
-    befehl->append( " LIMIT 21" );
-    lock();
-    if( !datenbank->befehl( *befehl ) )
-    {
-        unlock();
-        befehl->release();
-        Result res = { 0, 0, 0, 0 };
-        return res;
-    }
-    res = datenbank->getResult();
-    unlock();
-    befehl->release();
-    return res;
+	Text* befehl = new Text("SELECT count( a.id ) FROM account a, "
+		"( SELECT a.id, max( b.datum ) "
+		"  FROM account a LEFT JOIN "
+		"  ( SELECT g.spiel_art_id, i.account_id"
+		"    FROM karte g, spiel h, spiel_spieler i "
+		"    WHERE i.spiel_id = h.id AND h.karte_id = g.id AND h.beginn_datum = "
+		"   ( SELECT max( x.beginn_datum ) FROM spiel x, spiel_spieler y WHERE y.spiel_id = x.id AND y.account_id = i.account_id ) ) f ON a.id = f.account_id "
+		"  LEFT JOIN account_online b ON b.account_id = a.id "
+		"  LEFT JOIN spiel_statistik e ON e.account_id = a.id "
+		"  LEFT JOIN spiel_art c ON c.id = f.spiel_art_id "
+		"  LEFT JOIN karte d ON c.id = d.spiel_art_id "
+		"  WHERE a.name LIKE '");
+	befehl->append(suche);
+	befehl->append("' AND d.spiel_art_id = c.id "
+		"  AND e.spiel_art_id = f.spiel_art_id "
+		"  GROUP BY a.id ) b "
+		"WHERE a.id = b.id");
+	lock();
+	if (!datenbank->befehl(*befehl))
+	{
+		unlock();
+		befehl->release();
+		Result res = { 0, 0, 0, 0 };
+		return res;
+	}
+	Result res = datenbank->getResult();
+	unlock();
+	if (!res.zeilenAnzahl)
+	{
+		res.destroy();
+		befehl->release();
+		Result res = { 0, 0, 0, 0 };
+		return res;
+	}
+	int entrys = (int)res.values[0];
+	res.destroy();
+	*maxSeite = entrys / 21;
+	if (entrys % 21)
+		(*maxSeite)++;
+	if (*seite > *maxSeite)
+		*seite = *maxSeite;
+	if (!(*seite))
+	{
+		befehl->release();
+		Result res = { 0, 0, 0, 0 };
+		return res;
+	}
+	befehl->setText("SELECT a.id, a.ruf_name, max( b.datum ), c.name, d.name, e.punkte "
+		"FROM account a LEFT JOIN "
+		"( SELECT g.spiel_art_id, i.account_id "
+		"  FROM karte g, spiel h, spiel_spieler i "
+		"  WHERE i.spiel_id = h.id AND h.karte_id = g.id AND h.beginn_datum = "
+		"( SELECT max( x.beginn_datum ) FROM spiel x, spiel_spieler y WHERE y.spiel_id = x.id AND y.account_id = i.account_id ) ) f ON a.id = f.account_id "
+		"LEFT JOIN account_online b ON b.account_id = a.id "
+		"LEFT JOIN spiel_statistik e ON e.account_id = a.id "
+		"LEFT JOIN spiel_art c ON c.id = f.spiel_art_id "
+		"LEFT JOIN karte d ON c.id = d.spiel_art_id "
+		"WHERE a.name LIKE '");
+	befehl->append(suche);
+	befehl->append("' AND ( d.spiel_art_id = c.id "
+		"AND e.spiel_art_id = f.spiel_art_id ) "
+		"OR d.spiel_art_id IS NULL "
+		"GROUP BY a.id, a.ruf_name, c.name, d.name, e.punkte ORDER BY ");
+	befehl->append(sortStalte + 2);
+	if (backwords)
+		befehl->append(" DESC");
+	befehl->append(" OFFSET ");
+	befehl->append(((*seite) - 1) * 21);
+	befehl->append(" LIMIT 21");
+	lock();
+	if (!datenbank->befehl(*befehl))
+	{
+		unlock();
+		befehl->release();
+		Result res = { 0, 0, 0, 0 };
+		return res;
+	}
+	res = datenbank->getResult();
+	unlock();
+	befehl->release();
+	return res;
 }
 
-bool ISDatenbank::getSpielerAktivity( int accountId, RCArray< Text > *datum, Array< double > *stOnline, Array< double > *stGespielt,
-                                      Array< int > *anzSpiele, Array< int > *anzGewonnen )
+bool ISDatenbank::getSpielerAktivity(int accountId, RCArray< Text >* datum, Array< double >* stOnline, Array< double >* stGespielt,
+	Array< int >* anzSpiele, Array< int >* anzGewonnen)
 {
-    Datum *beg = getDatum();
-    Datum *end = getDatum();
-    beg->minusTag( 29 );
-    end->minusTag( 29 );
-    end->plusTag( 1 );
-    for( int i = 0; i < 30; i++ )
-    { // 30 Tage Rückblick
-        datum->add( beg->getDatum( "d-m-y" ) );
-        Text *b = beg->getDatum( "y-m-d" );
-        Text *e = end->getDatum( "y-m-d" );
-        stOnline->add( getOnlineSeconds( accountId, *b, *e ) / ( 60.0 * 60 ) );
-        stGespielt->add( getGespieltSeconds( accountId, *b, *e ) / ( 60.0 * 60 ) );
-        anzSpiele->add( getGespieltSpiele( accountId, *b, *e ) );
-        anzGewonnen->add( getGewonnenSpiele( accountId, *b, *e ) );
-        b->release();
-        e->release();
-        beg->plusTag( 1 );
-        end->plusTag( 1 );
-    }
-    return 1;
+	Datum* beg = getDatum();
+	Datum* end = getDatum();
+	beg->minusTag(29);
+	end->minusTag(29);
+	end->plusTag(1);
+	for (int i = 0; i < 30; i++)
+	{ // 30 Tage Rückblick
+		datum->add(beg->getDatum("d-m-y"));
+		Text* b = beg->getDatum("y-m-d");
+		Text* e = end->getDatum("y-m-d");
+		stOnline->add(getOnlineSeconds(accountId, *b, *e) / (60.0 * 60));
+		stGespielt->add(getGespieltSeconds(accountId, *b, *e) / (60.0 * 60));
+		anzSpiele->add(getGespieltSpiele(accountId, *b, *e));
+		anzGewonnen->add(getGewonnenSpiele(accountId, *b, *e));
+		b->release();
+		e->release();
+		beg->plusTag(1);
+		end->plusTag(1);
+	}
+	return 1;
 }
 
-int ISDatenbank::getOnlineSeconds( int accountId, char *beg, char *end )
+int ISDatenbank::getOnlineSeconds(int accountId, const char* beg, const char* end)
 {
-    int sec = 0;
-    Text *befehl = new Text( "SELECT date_part( 'epoch', ( SELECT sum( now() - '" );
-    befehl->append( beg );
-    befehl->append( "' ) FROM account_online WHERE datum < '" );
-    befehl->append( beg );
-    befehl->append( "' AND now() < '" );
-    befehl->append( end );
-    befehl->append( "' AND now() > '" );
-    befehl->append( beg );
-    befehl->append( "' AND end_datum IS NULL AND account_id = " );
-    befehl->append( accountId );
-    befehl->append( " )::INTERVAL )" );
-    lock();
-    if( !datenbank->befehl( *befehl ) )
-    {
-        unlock();
-        befehl->release();
-        return 0;
-    }
-    Result res = datenbank->getResult();
-    unlock();
-    if( res.zeilenAnzahl )
-        sec += (int)res.values[ 0 ];
-    res.destroy();
-    befehl->setText( "SELECT date_part( 'epoch', ( SELECT sum( now() - datum ) FROM account_online WHERE datum > '" );
-    befehl->append( beg );
-    befehl->append( "' AND now() < '" );
-    befehl->append( end );
-    befehl->append( "' AND end_datum IS NULL AND account_id = " );
-    befehl->append( accountId );
-    befehl->append( " )::INTERVAL )" );
-    lock();
-    if( !datenbank->befehl( *befehl ) )
-    {
-        unlock();
-        befehl->release();
-        return 0;
-    }
-    res = datenbank->getResult();
-    unlock();
-    if( res.zeilenAnzahl )
-        sec += (int)res.values[ 0 ];
-    res.destroy();
-    befehl->setText( "SELECT date_part( 'epoch', ( SELECT sum( '" );
-    befehl->append( end );
-    befehl->append( "' - datum ) FROM account_online WHERE datum > '" );
-    befehl->append( beg );
-    befehl->append( "' AND datum < '" );
-    befehl->append( end );
-    befehl->append( "' AND now() > '" );
-    befehl->append( end );
-    befehl->append( "' AND end_datum IS NULL AND account_id = " );
-    befehl->append( accountId );
-    befehl->append( " )::INTERVAL )" );
-    lock();
-    if( !datenbank->befehl( *befehl ) )
-    {
-        unlock();
-        befehl->release();
-        return 0;
-    }
-    res = datenbank->getResult();
-    unlock();
-    if( res.zeilenAnzahl )
-        sec += (int)res.values[ 0 ];
-    res.destroy();
-    befehl->setText( "SELECT date_part( 'epoch', ( SELECT sum( '" );
-    befehl->append( end );
-    befehl->append( "'::TIMESTAMP WITH TIME ZONE - '" );
-    befehl->append( beg );
-    befehl->append( "' ) FROM account_online WHERE datum < '" );
-    befehl->append( beg );
-    befehl->append( "' AND now() > '" );
-    befehl->append( end );
-    befehl->append( "' AND end_datum IS NULL AND account_id = " );
-    befehl->append( accountId );
-    befehl->append( " )::INTERVAL )" );
-    lock();
-    if( !datenbank->befehl( *befehl ) )
-    {
-        unlock();
-        befehl->release();
-        return 0;
-    }
-    res = datenbank->getResult();
-    unlock();
-    if( res.zeilenAnzahl )
-        sec += (int)res.values[ 0 ];
-    res.destroy();
-    befehl->setText( "SELECT date_part( 'epoch', ( SELECT sum( end_datum - '" );
-    befehl->append( beg );
-    befehl->append( "' ) FROM account_online WHERE datum < '" );
-    befehl->append( beg );
-    befehl->append( "' AND end_datum < '" );
-    befehl->append( end );
-    befehl->append( "' AND end_datum > '" );
-    befehl->append( beg );
-    befehl->append( "' AND account_id = " );
-    befehl->append( accountId );
-    befehl->append( " )::INTERVAL )" );
-    lock();
-    if( !datenbank->befehl( *befehl ) )
-    {
-        unlock();
-        befehl->release();
-        return 0;
-    }
-    res = datenbank->getResult();
-    unlock();
-    if( res.zeilenAnzahl )
-        sec += (int)res.values[ 0 ];
-    res.destroy();
-    befehl->setText( "SELECT date_part( 'epoch', ( SELECT sum( end_datum - datum ) FROM account_online WHERE datum > '" );
-    befehl->append( beg );
-    befehl->append( "' AND end_datum < '" );
-    befehl->append( end );
-    befehl->append( "' AND account_id = " );
-    befehl->append( accountId );
-    befehl->append( " )::INTERVAL )" );
-    lock();
-    if( !datenbank->befehl( *befehl ) )
-    {
-        unlock();
-        befehl->release();
-        return 0;
-    }
-    res = datenbank->getResult();
-    unlock();
-    if( res.zeilenAnzahl )
-        sec += (int)res.values[ 0 ];
-    res.destroy();
-    befehl->setText( "SELECT date_part( 'epoch', ( SELECT sum( '" );
-    befehl->append( end );
-    befehl->append( "' - datum ) FROM account_online WHERE datum > '" );
-    befehl->append( beg );
-    befehl->append( "' AND datum < '" );
-    befehl->append( end );
-    befehl->append( "' AND end_datum > '" );
-    befehl->append( end );
-    befehl->append( "' AND account_id = " );
-    befehl->append( accountId );
-    befehl->append( " )::INTERVAL )" );
-    lock();
-    if( !datenbank->befehl( *befehl ) )
-    {
-        unlock();
-        befehl->release();
-        return 0;
-    }
-    res = datenbank->getResult();
-    unlock();
-    if( res.zeilenAnzahl )
-        sec += (int)res.values[ 0 ];
-    res.destroy();
-    befehl->setText( "SELECT date_part( 'epoch', ( SELECT sum( '" );
-    befehl->append( end );
-    befehl->append( "'::TIMESTAMP WITH TIME ZONE - '" );
-    befehl->append( beg );
-    befehl->append( "' ) FROM account_online WHERE datum < '" );
-    befehl->append( beg );
-    befehl->append( "' AND end_datum > '" );
-    befehl->append( end );
-    befehl->append( "' AND account_id = " );
-    befehl->append( accountId );
-    befehl->append( " )::INTERVAL )" );
-    lock();
-    if( !datenbank->befehl( *befehl ) )
-    {
-        unlock();
-        befehl->release();
-        return 0;
-    }
-    res = datenbank->getResult();
-    unlock();
-    if( res.zeilenAnzahl )
-        sec += (int)res.values[ 0 ];
-    res.destroy();
-    befehl->release();
-    return sec;
+	int sec = 0;
+	Text* befehl = new Text("SELECT date_part( 'epoch', ( SELECT sum( now() - '");
+	befehl->append(beg);
+	befehl->append("' ) FROM account_online WHERE datum < '");
+	befehl->append(beg);
+	befehl->append("' AND now() < '");
+	befehl->append(end);
+	befehl->append("' AND now() > '");
+	befehl->append(beg);
+	befehl->append("' AND end_datum IS NULL AND account_id = ");
+	befehl->append(accountId);
+	befehl->append(" )::INTERVAL )");
+	lock();
+	if (!datenbank->befehl(*befehl))
+	{
+		unlock();
+		befehl->release();
+		return 0;
+	}
+	Result res = datenbank->getResult();
+	unlock();
+	if (res.zeilenAnzahl)
+		sec += (int)res.values[0];
+	res.destroy();
+	befehl->setText("SELECT date_part( 'epoch', ( SELECT sum( now() - datum ) FROM account_online WHERE datum > '");
+	befehl->append(beg);
+	befehl->append("' AND now() < '");
+	befehl->append(end);
+	befehl->append("' AND end_datum IS NULL AND account_id = ");
+	befehl->append(accountId);
+	befehl->append(" )::INTERVAL )");
+	lock();
+	if (!datenbank->befehl(*befehl))
+	{
+		unlock();
+		befehl->release();
+		return 0;
+	}
+	res = datenbank->getResult();
+	unlock();
+	if (res.zeilenAnzahl)
+		sec += (int)res.values[0];
+	res.destroy();
+	befehl->setText("SELECT date_part( 'epoch', ( SELECT sum( '");
+	befehl->append(end);
+	befehl->append("' - datum ) FROM account_online WHERE datum > '");
+	befehl->append(beg);
+	befehl->append("' AND datum < '");
+	befehl->append(end);
+	befehl->append("' AND now() > '");
+	befehl->append(end);
+	befehl->append("' AND end_datum IS NULL AND account_id = ");
+	befehl->append(accountId);
+	befehl->append(" )::INTERVAL )");
+	lock();
+	if (!datenbank->befehl(*befehl))
+	{
+		unlock();
+		befehl->release();
+		return 0;
+	}
+	res = datenbank->getResult();
+	unlock();
+	if (res.zeilenAnzahl)
+		sec += (int)res.values[0];
+	res.destroy();
+	befehl->setText("SELECT date_part( 'epoch', ( SELECT sum( '");
+	befehl->append(end);
+	befehl->append("'::TIMESTAMP WITH TIME ZONE - '");
+	befehl->append(beg);
+	befehl->append("' ) FROM account_online WHERE datum < '");
+	befehl->append(beg);
+	befehl->append("' AND now() > '");
+	befehl->append(end);
+	befehl->append("' AND end_datum IS NULL AND account_id = ");
+	befehl->append(accountId);
+	befehl->append(" )::INTERVAL )");
+	lock();
+	if (!datenbank->befehl(*befehl))
+	{
+		unlock();
+		befehl->release();
+		return 0;
+	}
+	res = datenbank->getResult();
+	unlock();
+	if (res.zeilenAnzahl)
+		sec += (int)res.values[0];
+	res.destroy();
+	befehl->setText("SELECT date_part( 'epoch', ( SELECT sum( end_datum - '");
+	befehl->append(beg);
+	befehl->append("' ) FROM account_online WHERE datum < '");
+	befehl->append(beg);
+	befehl->append("' AND end_datum < '");
+	befehl->append(end);
+	befehl->append("' AND end_datum > '");
+	befehl->append(beg);
+	befehl->append("' AND account_id = ");
+	befehl->append(accountId);
+	befehl->append(" )::INTERVAL )");
+	lock();
+	if (!datenbank->befehl(*befehl))
+	{
+		unlock();
+		befehl->release();
+		return 0;
+	}
+	res = datenbank->getResult();
+	unlock();
+	if (res.zeilenAnzahl)
+		sec += (int)res.values[0];
+	res.destroy();
+	befehl->setText("SELECT date_part( 'epoch', ( SELECT sum( end_datum - datum ) FROM account_online WHERE datum > '");
+	befehl->append(beg);
+	befehl->append("' AND end_datum < '");
+	befehl->append(end);
+	befehl->append("' AND account_id = ");
+	befehl->append(accountId);
+	befehl->append(" )::INTERVAL )");
+	lock();
+	if (!datenbank->befehl(*befehl))
+	{
+		unlock();
+		befehl->release();
+		return 0;
+	}
+	res = datenbank->getResult();
+	unlock();
+	if (res.zeilenAnzahl)
+		sec += (int)res.values[0];
+	res.destroy();
+	befehl->setText("SELECT date_part( 'epoch', ( SELECT sum( '");
+	befehl->append(end);
+	befehl->append("' - datum ) FROM account_online WHERE datum > '");
+	befehl->append(beg);
+	befehl->append("' AND datum < '");
+	befehl->append(end);
+	befehl->append("' AND end_datum > '");
+	befehl->append(end);
+	befehl->append("' AND account_id = ");
+	befehl->append(accountId);
+	befehl->append(" )::INTERVAL )");
+	lock();
+	if (!datenbank->befehl(*befehl))
+	{
+		unlock();
+		befehl->release();
+		return 0;
+	}
+	res = datenbank->getResult();
+	unlock();
+	if (res.zeilenAnzahl)
+		sec += (int)res.values[0];
+	res.destroy();
+	befehl->setText("SELECT date_part( 'epoch', ( SELECT sum( '");
+	befehl->append(end);
+	befehl->append("'::TIMESTAMP WITH TIME ZONE - '");
+	befehl->append(beg);
+	befehl->append("' ) FROM account_online WHERE datum < '");
+	befehl->append(beg);
+	befehl->append("' AND end_datum > '");
+	befehl->append(end);
+	befehl->append("' AND account_id = ");
+	befehl->append(accountId);
+	befehl->append(" )::INTERVAL )");
+	lock();
+	if (!datenbank->befehl(*befehl))
+	{
+		unlock();
+		befehl->release();
+		return 0;
+	}
+	res = datenbank->getResult();
+	unlock();
+	if (res.zeilenAnzahl)
+		sec += (int)res.values[0];
+	res.destroy();
+	befehl->release();
+	return sec;
 }
 
-int ISDatenbank::getGespieltSeconds( int accountId, char *beg, char *end )
+int ISDatenbank::getGespieltSeconds(int accountId, const char* beg, const char* end)
 {
-    int sec = 0;
-    Text *befehl = new Text( "SELECT date_part( 'epoch', ( SELECT sum( now() - '" );
-    befehl->append( beg );
-    befehl->append( "' ) FROM spiel a, spiel_spieler b WHERE a.beginn_datum < '" );
-    befehl->append( beg );
-    befehl->append( "' AND now() < '" );
-    befehl->append( end );
-    befehl->append( "' AND now() > '" );
-    befehl->append( beg );
-    befehl->append( "' AND a.end_datum IS NULL AND a.id = b.spiel_id AND b.account_id = " );
-    befehl->append( accountId );
-    befehl->append( " )::INTERVAL )" );
-    lock();
-    if( !datenbank->befehl( *befehl ) )
-    {
-        unlock();
-        befehl->release();
-        return 0;
-    }
-    Result res = datenbank->getResult();
-    unlock();
-    if( res.zeilenAnzahl )
-        sec += (int)res.values[ 0 ];
-    res.destroy();
-    befehl->setText( "SELECT date_part( 'epoch', ( SELECT sum( now() - a.beginn_datum ) FROM spiel a, spiel_spieler b WHERE a.beginn_datum > '" );
-    befehl->append( beg );
-    befehl->append( "' AND now() < '" );
-    befehl->append( end );
-    befehl->append( "' AND a.end_datum IS NULL AND a.id = b.spiel_id AND b.account_id = " );
-    befehl->append( accountId );
-    befehl->append( " )::INTERVAL )" );
-    lock();
-    if( !datenbank->befehl( *befehl ) )
-    {
-        unlock();
-        befehl->release();
-        return 0;
-    }
-    res = datenbank->getResult();
-    unlock();
-    if( res.zeilenAnzahl )
-        sec += (int)res.values[ 0 ];
-    res.destroy();
-    befehl->setText( "SELECT date_part( 'epoch', ( SELECT sum( '" );
-    befehl->append( end );
-    befehl->append( "' - a.beginn_datum ) FROM spiel a, spiel_spieler b WHERE a.beginn_datum > '" );
-    befehl->append( beg );
-    befehl->append( "' AND a.beginn_datum < '" );
-    befehl->append( end );
-    befehl->append( "' AND now() > '" );
-    befehl->append( end );
-    befehl->append( "' AND a.end_datum IS NULL AND a.id = b.spiel_id AND b.account_id = " );
-    befehl->append( accountId );
-    befehl->append( " )::INTERVAL )" );
-    lock();
-    if( !datenbank->befehl( *befehl ) )
-    {
-        unlock();
-        befehl->release();
-        return 0;
-    }
-    res = datenbank->getResult();
-    unlock();
-    if( res.zeilenAnzahl )
-        sec += (int)res.values[ 0 ];
-    res.destroy();
-    befehl->setText( "SELECT date_part( 'epoch', ( SELECT sum( '" );
-    befehl->append( end );
-    befehl->append( "'::TIMESTAMP WITH TIME ZONE - '" );
-    befehl->append( beg );
-    befehl->append( "' ) FROM spiel a, spiel_spieler b WHERE a.beginn_datum < '" );
-    befehl->append( beg );
-    befehl->append( "' AND now() > '" );
-    befehl->append( end );
-    befehl->append( "' AND a.end_datum IS NULL AND a.id = b.spiel_id AND b.account_id = " );
-    befehl->append( accountId );
-    befehl->append( " )::INTERVAL )" );
-    lock();
-    if( !datenbank->befehl( *befehl ) )
-    {
-        unlock();
-        befehl->release();
-        return 0;
-    }
-    res = datenbank->getResult();
-    unlock();
-    if( res.zeilenAnzahl )
-        sec += (int)res.values[ 0 ];
-    res.destroy();
-    befehl->setText( "SELECT date_part( 'epoch', ( SELECT sum( a.end_datum - '" );
-    befehl->append( beg );
-    befehl->append( "' ) FROM spiel a, spiel_spieler b WHERE a.beginn_datum < '" );
-    befehl->append( beg );
-    befehl->append( "' AND a.end_datum < '" );
-    befehl->append( end );
-    befehl->append( "' AND a.end_datum > '" );
-    befehl->append( beg );
-    befehl->append( "' AND a.id = b.spiel_id AND b.account_id = " );
-    befehl->append( accountId );
-    befehl->append( " )::INTERVAL )" );
-    lock();
-    if( !datenbank->befehl( *befehl ) )
-    {
-        unlock();
-        befehl->release();
-        return 0;
-    }
-    res = datenbank->getResult();
-    unlock();
-    if( res.zeilenAnzahl )
-        sec += (int)res.values[ 0 ];
-    res.destroy();
-    befehl->setText( "SELECT date_part( 'epoch', ( SELECT sum( a.end_datum - a.beginn_datum ) FROM spiel a, spiel_spieler b WHERE a.beginn_datum > '" );
-    befehl->append( beg );
-    befehl->append( "' AND a.end_datum < '" );
-    befehl->append( end );
-    befehl->append( "' AND a.id = b.spiel_id AND b.account_id = " );
-    befehl->append( accountId );
-    befehl->append( " )::INTERVAL )" );
-    lock();
-    if( !datenbank->befehl( *befehl ) )
-    {
-        unlock();
-        befehl->release();
-        return 0;
-    }
-    res = datenbank->getResult();
-    unlock();
-    if( res.zeilenAnzahl )
-        sec += (int)res.values[ 0 ];
-    res.destroy();
-    befehl->setText( "SELECT date_part( 'epoch', ( SELECT sum( '" );
-    befehl->append( end );
-    befehl->append( "' - a.beginn_datum ) FROM spiel a, spiel_spieler b WHERE a.beginn_datum > '" );
-    befehl->append( beg );
-    befehl->append( "' AND a.beginn_datum < '" );
-    befehl->append( end );
-    befehl->append( "' AND a.end_datum > '" );
-    befehl->append( end );
-    befehl->append( "' AND a.id = b.spiel_id AND account_id = " );
-    befehl->append( accountId );
-    befehl->append( " )::INTERVAL )" );
-    lock();
-    if( !datenbank->befehl( *befehl ) )
-    {
-        unlock();
-        befehl->release();
-        return 0;
-    }
-    res = datenbank->getResult();
-    unlock();
-    if( res.zeilenAnzahl )
-        sec += (int)res.values[ 0 ];
-    res.destroy();
-    befehl->setText( "SELECT date_part( 'epoch', ( SELECT sum( '" );
-    befehl->append( end );
-    befehl->append( "'::TIMESTAMP WITH TIME ZONE - '" );
-    befehl->append( beg );
-    befehl->append( "' ) FROM spiel a, spiel_spieler b WHERE a.beginn_datum < '" );
-    befehl->append( beg );
-    befehl->append( "' AND a.end_datum > '" );
-    befehl->append( end );
-    befehl->append( "' AND a.id = b.spiel_id AND account_id = " );
-    befehl->append( accountId );
-    befehl->append( " )::INTERVAL )" );
-    lock();
-    if( !datenbank->befehl( *befehl ) )
-    {
-        unlock();
-        befehl->release();
-        return 0;
-    }
-    res = datenbank->getResult();
-    unlock();
-    if( res.zeilenAnzahl )
-        sec += (int)res.values[ 0 ];
-    res.destroy();
-    befehl->release();
-    return sec;
+	int sec = 0;
+	Text* befehl = new Text("SELECT date_part( 'epoch', ( SELECT sum( now() - '");
+	befehl->append(beg);
+	befehl->append("' ) FROM spiel a, spiel_spieler b WHERE a.beginn_datum < '");
+	befehl->append(beg);
+	befehl->append("' AND now() < '");
+	befehl->append(end);
+	befehl->append("' AND now() > '");
+	befehl->append(beg);
+	befehl->append("' AND a.end_datum IS NULL AND a.id = b.spiel_id AND b.account_id = ");
+	befehl->append(accountId);
+	befehl->append(" )::INTERVAL )");
+	lock();
+	if (!datenbank->befehl(*befehl))
+	{
+		unlock();
+		befehl->release();
+		return 0;
+	}
+	Result res = datenbank->getResult();
+	unlock();
+	if (res.zeilenAnzahl)
+		sec += (int)res.values[0];
+	res.destroy();
+	befehl->setText("SELECT date_part( 'epoch', ( SELECT sum( now() - a.beginn_datum ) FROM spiel a, spiel_spieler b WHERE a.beginn_datum > '");
+	befehl->append(beg);
+	befehl->append("' AND now() < '");
+	befehl->append(end);
+	befehl->append("' AND a.end_datum IS NULL AND a.id = b.spiel_id AND b.account_id = ");
+	befehl->append(accountId);
+	befehl->append(" )::INTERVAL )");
+	lock();
+	if (!datenbank->befehl(*befehl))
+	{
+		unlock();
+		befehl->release();
+		return 0;
+	}
+	res = datenbank->getResult();
+	unlock();
+	if (res.zeilenAnzahl)
+		sec += (int)res.values[0];
+	res.destroy();
+	befehl->setText("SELECT date_part( 'epoch', ( SELECT sum( '");
+	befehl->append(end);
+	befehl->append("' - a.beginn_datum ) FROM spiel a, spiel_spieler b WHERE a.beginn_datum > '");
+	befehl->append(beg);
+	befehl->append("' AND a.beginn_datum < '");
+	befehl->append(end);
+	befehl->append("' AND now() > '");
+	befehl->append(end);
+	befehl->append("' AND a.end_datum IS NULL AND a.id = b.spiel_id AND b.account_id = ");
+	befehl->append(accountId);
+	befehl->append(" )::INTERVAL )");
+	lock();
+	if (!datenbank->befehl(*befehl))
+	{
+		unlock();
+		befehl->release();
+		return 0;
+	}
+	res = datenbank->getResult();
+	unlock();
+	if (res.zeilenAnzahl)
+		sec += (int)res.values[0];
+	res.destroy();
+	befehl->setText("SELECT date_part( 'epoch', ( SELECT sum( '");
+	befehl->append(end);
+	befehl->append("'::TIMESTAMP WITH TIME ZONE - '");
+	befehl->append(beg);
+	befehl->append("' ) FROM spiel a, spiel_spieler b WHERE a.beginn_datum < '");
+	befehl->append(beg);
+	befehl->append("' AND now() > '");
+	befehl->append(end);
+	befehl->append("' AND a.end_datum IS NULL AND a.id = b.spiel_id AND b.account_id = ");
+	befehl->append(accountId);
+	befehl->append(" )::INTERVAL )");
+	lock();
+	if (!datenbank->befehl(*befehl))
+	{
+		unlock();
+		befehl->release();
+		return 0;
+	}
+	res = datenbank->getResult();
+	unlock();
+	if (res.zeilenAnzahl)
+		sec += (int)res.values[0];
+	res.destroy();
+	befehl->setText("SELECT date_part( 'epoch', ( SELECT sum( a.end_datum - '");
+	befehl->append(beg);
+	befehl->append("' ) FROM spiel a, spiel_spieler b WHERE a.beginn_datum < '");
+	befehl->append(beg);
+	befehl->append("' AND a.end_datum < '");
+	befehl->append(end);
+	befehl->append("' AND a.end_datum > '");
+	befehl->append(beg);
+	befehl->append("' AND a.id = b.spiel_id AND b.account_id = ");
+	befehl->append(accountId);
+	befehl->append(" )::INTERVAL )");
+	lock();
+	if (!datenbank->befehl(*befehl))
+	{
+		unlock();
+		befehl->release();
+		return 0;
+	}
+	res = datenbank->getResult();
+	unlock();
+	if (res.zeilenAnzahl)
+		sec += (int)res.values[0];
+	res.destroy();
+	befehl->setText("SELECT date_part( 'epoch', ( SELECT sum( a.end_datum - a.beginn_datum ) FROM spiel a, spiel_spieler b WHERE a.beginn_datum > '");
+	befehl->append(beg);
+	befehl->append("' AND a.end_datum < '");
+	befehl->append(end);
+	befehl->append("' AND a.id = b.spiel_id AND b.account_id = ");
+	befehl->append(accountId);
+	befehl->append(" )::INTERVAL )");
+	lock();
+	if (!datenbank->befehl(*befehl))
+	{
+		unlock();
+		befehl->release();
+		return 0;
+	}
+	res = datenbank->getResult();
+	unlock();
+	if (res.zeilenAnzahl)
+		sec += (int)res.values[0];
+	res.destroy();
+	befehl->setText("SELECT date_part( 'epoch', ( SELECT sum( '");
+	befehl->append(end);
+	befehl->append("' - a.beginn_datum ) FROM spiel a, spiel_spieler b WHERE a.beginn_datum > '");
+	befehl->append(beg);
+	befehl->append("' AND a.beginn_datum < '");
+	befehl->append(end);
+	befehl->append("' AND a.end_datum > '");
+	befehl->append(end);
+	befehl->append("' AND a.id = b.spiel_id AND account_id = ");
+	befehl->append(accountId);
+	befehl->append(" )::INTERVAL )");
+	lock();
+	if (!datenbank->befehl(*befehl))
+	{
+		unlock();
+		befehl->release();
+		return 0;
+	}
+	res = datenbank->getResult();
+	unlock();
+	if (res.zeilenAnzahl)
+		sec += (int)res.values[0];
+	res.destroy();
+	befehl->setText("SELECT date_part( 'epoch', ( SELECT sum( '");
+	befehl->append(end);
+	befehl->append("'::TIMESTAMP WITH TIME ZONE - '");
+	befehl->append(beg);
+	befehl->append("' ) FROM spiel a, spiel_spieler b WHERE a.beginn_datum < '");
+	befehl->append(beg);
+	befehl->append("' AND a.end_datum > '");
+	befehl->append(end);
+	befehl->append("' AND a.id = b.spiel_id AND account_id = ");
+	befehl->append(accountId);
+	befehl->append(" )::INTERVAL )");
+	lock();
+	if (!datenbank->befehl(*befehl))
+	{
+		unlock();
+		befehl->release();
+		return 0;
+	}
+	res = datenbank->getResult();
+	unlock();
+	if (res.zeilenAnzahl)
+		sec += (int)res.values[0];
+	res.destroy();
+	befehl->release();
+	return sec;
 }
 
-int ISDatenbank::getGespieltSpiele( int accountId, char *beg, char *end )
+int ISDatenbank::getGespieltSpiele(int accountId, const char* beg, const char* end)
 {
-    int anz = 0;
-    Text *befehl = new Text( "SELECT count( a.id ) FROM spiel a, spiel_spieler b WHERE a.beginn_datum < '" );
-    befehl->append( beg );
-    befehl->append( "' AND a.end_datum < '" );
-    befehl->append( end );
-    befehl->append( "' AND a.end_datum > '" );
-    befehl->append( beg );
-    befehl->append( "' AND a.id = b.spiel_id AND b.account_id = " );
-    befehl->append( accountId );
-    lock();
-    if( !datenbank->befehl( *befehl ) )
-    {
-        unlock();
-        befehl->release();
-        return 0;
-    }
-    Result res = datenbank->getResult();
-    unlock();
-    if( res.zeilenAnzahl )
-        anz += (int)res.values[ 0 ];
-    res.destroy();
-    befehl->setText( "SELECT count( a.id ) FROM spiel a, spiel_spieler b WHERE a.beginn_datum > '" );
-    befehl->append( beg );
-    befehl->append( "' AND a.end_datum < '" );
-    befehl->append( end );
-    befehl->append( "' AND a.id = b.spiel_id AND b.account_id = " );
-    befehl->append( accountId );
-    lock();
-    if( !datenbank->befehl( *befehl ) )
-    {
-        unlock();
-        befehl->release();
-        return 0;
-    }
-    res = datenbank->getResult();
-    unlock();
-    if( res.zeilenAnzahl )
-        anz += (int)res.values[ 0 ];
-    res.destroy();
-    befehl->release();
-    return anz;
+	int anz = 0;
+	Text* befehl = new Text("SELECT count( a.id ) FROM spiel a, spiel_spieler b WHERE a.beginn_datum < '");
+	befehl->append(beg);
+	befehl->append("' AND a.end_datum < '");
+	befehl->append(end);
+	befehl->append("' AND a.end_datum > '");
+	befehl->append(beg);
+	befehl->append("' AND a.id = b.spiel_id AND b.account_id = ");
+	befehl->append(accountId);
+	lock();
+	if (!datenbank->befehl(*befehl))
+	{
+		unlock();
+		befehl->release();
+		return 0;
+	}
+	Result res = datenbank->getResult();
+	unlock();
+	if (res.zeilenAnzahl)
+		anz += (int)res.values[0];
+	res.destroy();
+	befehl->setText("SELECT count( a.id ) FROM spiel a, spiel_spieler b WHERE a.beginn_datum > '");
+	befehl->append(beg);
+	befehl->append("' AND a.end_datum < '");
+	befehl->append(end);
+	befehl->append("' AND a.id = b.spiel_id AND b.account_id = ");
+	befehl->append(accountId);
+	lock();
+	if (!datenbank->befehl(*befehl))
+	{
+		unlock();
+		befehl->release();
+		return 0;
+	}
+	res = datenbank->getResult();
+	unlock();
+	if (res.zeilenAnzahl)
+		anz += (int)res.values[0];
+	res.destroy();
+	befehl->release();
+	return anz;
 }
 
-int ISDatenbank::getGewonnenSpiele( int accountId, char *beg, char *end )
+int ISDatenbank::getGewonnenSpiele(int accountId, const char* beg, const char* end)
 {
-    int anz = 0;
-    Text *befehl = new Text( "SELECT count( a.id ) FROM spiel a, spiel_spieler b WHERE a.beginn_datum < '" );
-    befehl->append( beg );
-    befehl->append( "' AND a.end_datum < '" );
-    befehl->append( end );
-    befehl->append( "' AND a.end_datum > '" );
-    befehl->append( beg );
-    befehl->append( "' AND a.id = b.spiel_id AND b.spiel_spieler_status_id = 2 AND b.account_id = " );
-    befehl->append( accountId );
-    lock();
-    if( !datenbank->befehl( *befehl ) )
-    {
-        unlock();
-        befehl->release();
-        return 0;
-    }
-    Result res = datenbank->getResult();
-    unlock();
-    if( res.zeilenAnzahl )
-        anz += (int)res.values[ 0 ];
-    res.destroy();
-    befehl->setText( "SELECT count( a.id ) FROM spiel a, spiel_spieler b WHERE a.beginn_datum > '" );
-    befehl->append( beg );
-    befehl->append( "' AND a.end_datum < '" );
-    befehl->append( end );
-    befehl->append( "' AND a.id = b.spiel_id AND b.spiel_spieler_status_id = 2 AND b.account_id = " );
-    befehl->append( accountId );
-    lock();
-    if( !datenbank->befehl( *befehl ) )
-    {
-        unlock();
-        befehl->release();
-        return 0;
-    }
-    res = datenbank->getResult();
-    unlock();
-    if( res.zeilenAnzahl )
-        anz += (int)res.values[ 0 ];
-    res.destroy();
-    befehl->release();
-    return anz;
+	int anz = 0;
+	Text* befehl = new Text("SELECT count( a.id ) FROM spiel a, spiel_spieler b WHERE a.beginn_datum < '");
+	befehl->append(beg);
+	befehl->append("' AND a.end_datum < '");
+	befehl->append(end);
+	befehl->append("' AND a.end_datum > '");
+	befehl->append(beg);
+	befehl->append("' AND a.id = b.spiel_id AND b.spiel_spieler_status_id = 2 AND b.account_id = ");
+	befehl->append(accountId);
+	lock();
+	if (!datenbank->befehl(*befehl))
+	{
+		unlock();
+		befehl->release();
+		return 0;
+	}
+	Result res = datenbank->getResult();
+	unlock();
+	if (res.zeilenAnzahl)
+		anz += (int)res.values[0];
+	res.destroy();
+	befehl->setText("SELECT count( a.id ) FROM spiel a, spiel_spieler b WHERE a.beginn_datum > '");
+	befehl->append(beg);
+	befehl->append("' AND a.end_datum < '");
+	befehl->append(end);
+	befehl->append("' AND a.id = b.spiel_id AND b.spiel_spieler_status_id = 2 AND b.account_id = ");
+	befehl->append(accountId);
+	lock();
+	if (!datenbank->befehl(*befehl))
+	{
+		unlock();
+		befehl->release();
+		return 0;
+	}
+	res = datenbank->getResult();
+	unlock();
+	if (res.zeilenAnzahl)
+		anz += (int)res.values[0];
+	res.destroy();
+	befehl->release();
+	return anz;
 }
 
-Result ISDatenbank::getSpielPartnerListe( int accountId )
+Result ISDatenbank::getSpielPartnerListe(int accountId)
 {
-    Text *befehl = new Text( "SELECT account_id_b, anzahl, karte_id FROM account_mitspieler WHERE account_id_a = " );
-    befehl->append( accountId );
-    lock();
-    if( !datenbank->befehl( *befehl ) )
-    {
-        unlock();
-        befehl->release();
-        Result res = { 0, 0, 0, 0 };
-        return res;
-    }
-    Result res = datenbank->getResult();
-    unlock();
-    befehl->release();
-    return res;
+	Text* befehl = new Text("SELECT account_id_b, anzahl, karte_id FROM account_mitspieler WHERE account_id_a = ");
+	befehl->append(accountId);
+	lock();
+	if (!datenbank->befehl(*befehl))
+	{
+		unlock();
+		befehl->release();
+		Result res = { 0, 0, 0, 0 };
+		return res;
+	}
+	Result res = datenbank->getResult();
+	unlock();
+	befehl->release();
+	return res;
 }
 
-Result ISDatenbank::getSpielStatistikListe( int accountId, int *seite, int *maxSeite, int sortStalte, bool backwords )
+Result ISDatenbank::getSpielStatistikListe(int accountId, int* seite, int* maxSeite, int sortStalte, bool backwords)
 {
-    Text *befehl = new Text( "SELECT count( spiel_art_id ) FROM spiel_statistik WHERE account_id = " );
-    befehl->append( accountId );
-    lock();
-    if( !datenbank->befehl( *befehl ) )
-    {
-        unlock();
-        befehl->release();
-        Result res = { 0, 0, 0, 0 };
-        return res;
-    }
-    Result res = datenbank->getResult();
-    unlock();
-    if( !res.zeilenAnzahl )
-    {
-        res.destroy();
-        befehl->release();
-        Result res = { 0, 0, 0, 0 };
-        return res;
-    }
-    int entrys = res.values[ 0 ];
-    res.destroy();
-    *maxSeite = entrys / 21;
-    if( entrys % 21 )
-        ( *maxSeite )++;
-    if( *seite > *maxSeite )
-        *seite = *maxSeite;
-    if( !( *seite ) )
-    {
-        befehl->release();
-        Result res = { 0, 0, 0, 0 };
-        return res;
-    }
-    befehl->setText( "SELECT a.id, a.name, b.gespielt, b.gewonnen, b.verloren, b.punkte, b.bw0, b.bw1, b.bw2, b.bw3, "
-                     "b.bw4, b.bw5 FROM spiel_art a, spiel_statistik b WHERE a.id = b.spiel_art_id AND b.account_id = " );
-    befehl->append( accountId );
-    befehl->append( " ORDER BY " );
-    befehl->append( sortStalte + 2 );
-    if( backwords )
-        befehl->append( " DESC" );
-    befehl->append( " OFFSET " );
-    befehl->append( ( ( *seite ) - 1 ) * 18 );
-    befehl->append( " LIMIT 18" );
-    lock();
-    if( !datenbank->befehl( *befehl ) )
-    {
-        unlock();
-        befehl->release();
-        Result res = { 0, 0, 0, 0 };
-        return res;
-    }
-    res = datenbank->getResult();
-    unlock();
-    befehl->release();
-    return res;
+	Text* befehl = new Text("SELECT count( spiel_art_id ) FROM spiel_statistik WHERE account_id = ");
+	befehl->append(accountId);
+	lock();
+	if (!datenbank->befehl(*befehl))
+	{
+		unlock();
+		befehl->release();
+		Result res = { 0, 0, 0, 0 };
+		return res;
+	}
+	Result res = datenbank->getResult();
+	unlock();
+	if (!res.zeilenAnzahl)
+	{
+		res.destroy();
+		befehl->release();
+		Result res = { 0, 0, 0, 0 };
+		return res;
+	}
+	int entrys = (int)res.values[0];
+	res.destroy();
+	*maxSeite = entrys / 21;
+	if (entrys % 21)
+		(*maxSeite)++;
+	if (*seite > *maxSeite)
+		*seite = *maxSeite;
+	if (!(*seite))
+	{
+		befehl->release();
+		Result res = { 0, 0, 0, 0 };
+		return res;
+	}
+	befehl->setText("SELECT a.id, a.name, b.gespielt, b.gewonnen, b.verloren, b.punkte, b.bw0, b.bw1, b.bw2, b.bw3, "
+		"b.bw4, b.bw5 FROM spiel_art a, spiel_statistik b WHERE a.id = b.spiel_art_id AND b.account_id = ");
+	befehl->append(accountId);
+	befehl->append(" ORDER BY ");
+	befehl->append(sortStalte + 2);
+	if (backwords)
+		befehl->append(" DESC");
+	befehl->append(" OFFSET ");
+	befehl->append(((*seite) - 1) * 18);
+	befehl->append(" LIMIT 18");
+	lock();
+	if (!datenbank->befehl(*befehl))
+	{
+		unlock();
+		befehl->release();
+		Result res = { 0, 0, 0, 0 };
+		return res;
+	}
+	res = datenbank->getResult();
+	unlock();
+	befehl->release();
+	return res;
 }
 
-AHDaten *ISDatenbank::getSpielHistorie( int accountId, InformationServer *is )
+AHDaten* ISDatenbank::getSpielHistorie(int accountId, InformationServer* is)
 {
-    Text *befehl = new Text( "SELECT a.id, a.karte_id, c.name, d.name, substring( a.beginn_datum::CHARACTER VARYING FOR 16 ), "
-                             "b.spiel_spieler_status_id, a.spiel_status_id, count( e.spiel_id ) "
-                             "FROM spiel a, spiel_spieler b, spiel_art c, karte d, (SELECT spiel_id FROM spiel_spieler) e "
-                             "WHERE a.id = e.spiel_id AND a.karte_id = d.id AND d.spiel_art_id = c.id "
-                             "AND a.id = b.spiel_id AND b.account_id = " );
-    *befehl += accountId;
-    *befehl += " GROUP BY a.id, a.karte_id, c.name, d.name, a.beginn_datum, b.spiel_spieler_status_id, a.spiel_status_id "
-        "ORDER BY beginn_datum DESC LIMIT 20";
-    lock();
-    if( !datenbank->befehl( *befehl ) )
-    {
-        unlock();
-        befehl->release();
-        return 0;
-    }
-    Result spielListe = datenbank->getResult();
-    unlock();
-    AHDaten *ret = new AHDaten();
-    for( int i = 0; i < spielListe.zeilenAnzahl; i++ )
-    {
-        SpielerTeamStruktur *sts = new SpielerTeamStruktur();
-        bool stsOK = 1;
-        KartenLeser *reader = new KartenLeser( spielListe.values[ 1 + i * spielListe.feldAnzahl ], is );
-        if( !reader->ladeSpielerTeamStruktur( sts ) )
-            stsOK = 0;
-        reader->release();
-        AHSpielDaten *spiel = new AHSpielDaten();
-        spiel->id = spielListe.values[ i * spielListe.feldAnzahl ];
-        spiel->karteId = spielListe.values[ 1 + i * spielListe.feldAnzahl ];
-        spiel->spiel->setText( spielListe.values[ 2 + i * spielListe.feldAnzahl ] );
-        spiel->karte->setText( spielListe.values[ 3 + i * spielListe.feldAnzahl ] );
-        spiel->datum->setText( spielListe.values[ 4 + i * spielListe.feldAnzahl ] );
-        switch( (int)spielListe.values[ 5 + i * spielListe.feldAnzahl ] )
-        {
-        case 1:
-            spiel->status->setText( "Verloren" );
-            break;
-        case 2:
-            spiel->status->setText( "Gewonnen" );
-            break;
-        case 3:
-            spiel->status->setText( "Nicht Anwesend" );
-            break;
-        case 4:
-            spiel->status->setText( "Beobachter" );
-            break;
-        case 5:
-            spiel->status->setText( "Unentschieden" );
-            break;
-        }
-        switch( (int)spielListe.values[ 6 + i * spielListe.feldAnzahl ] )
-        {
-        case 1:
-            spiel->spielStatus->setText( "Beginnt" );
-            break;
-        case 2:
-            spiel->spielStatus->setText( "Läuft" );
-            break;
-        case 3:
-            spiel->spielStatus->setText( "Abgebrochen" );
-            break;
-        case 4:
-            spiel->spielStatus->setText( "Fehlerhaft" );
-            break;
-        case 5:
-            spiel->spielStatus->setText( "Beendet" );
-            break;
-        case 6:
-            spiel->spielStatus->setText( "Unbewertet" );
-            break;
-        }
-        spiel->sAnzahl = spielListe.values[ 7 + i * spielListe.feldAnzahl ];
-        *befehl = "SELECT substring( (end_datum - beginn_datum)::CHARACTER VARYING FOR 8) FROM spiel WHERE id = ";
-        *befehl += spielListe.values[ i * spielListe.feldAnzahl ].getText();
-        lock();
-        if( datenbank->befehl( *befehl ) )
-        {
-            Result dauer = datenbank->getResult();
-            unlock();
-            if( dauer.zeilenAnzahl && dauer.values[ 0 ].getLength() )
-                spiel->dauer->setText( dauer.values[ 0 ] );
-        }
-        else
-            unlock();
-        int gewinnerTeam = -1;
-        if( stsOK )
-        {
-            *befehl = "SELECT team_id FROM spiel_spieler WHERE spiel_spieler_status_id = 2 AND spiel_id = ";
-            *befehl += spielListe.values[ i * spielListe.feldAnzahl ].getText();
-            lock();
-            if( datenbank->befehl( *befehl ) )
-            {
-                Result team = datenbank->getResult();
-                unlock();
-                if( team.zeilenAnzahl && team.values[ 0 ].getLength() && sts->teamName->z( team.values[ 0 ] ) )
-                {
-                    spiel->gewinner->setText( sts->teamName->z( team.values[ 0 ] )->getText() );
-                    gewinnerTeam = team.values[ 0 ];
-                }
-            }
-            else
-                unlock();
-        }
-        *befehl = "SELECT a.ruf_name, b.team_id, b.punkte, b.spiel_spieler_status_id, b.spieler_nummer FROM account a, spiel_spieler b WHERE b.account_id = a.id AND spiel_id = ";
-        *befehl += spielListe.values[ i * spielListe.feldAnzahl ].getText();
-        *befehl += " ORDER BY team_id";
-        lock();
-        if( datenbank->befehl( *befehl ) )
-        {
-            Result spielerListe = datenbank->getResult();
-            unlock();
-            for( int j = 0; j < spielerListe.zeilenAnzahl; j++ )
-            {
-                int tAnz = spiel->teams->getEintragAnzahl();
-                int index = -1;
-                for( int k = 0; k < tAnz; k++ )
-                {
-                    if( spiel->teams->z( k )->id == (int)spielerListe.values[ 1 + j * spielerListe.feldAnzahl ] )
-                    {
-                        index = k;
-                        break;
-                    }
-                }
-                if( index < 0 )
-                {
-                    index = tAnz;
-                    AHSpielTeamDaten *team = new AHSpielTeamDaten();
-                    team->id = spielerListe.values[ 1 + j * spielerListe.feldAnzahl ];
-                    if( sts->teamName->z( team->id ) )
-                        team->name->setText( sts->teamName->z( team->id )->getText() );
-                    team->sAnzahl = 0;
-                    if( team->id == gewinnerTeam )
-                        team->status->setText( "Gewonnen" );
-                    else
-                        team->status->setText( "Verloren" );
-                    if( sts->teamFarbe->hat( team->id ) )
-                        team->farbe = sts->teamFarbe->get( team->id );
-                    else
-                        team->farbe = 0;
-                    spiel->teams->add( team );
-                }
-                AHSpielSpielerDaten *spieler = new AHSpielSpielerDaten();
-                spieler->name->setText( spielerListe.values[ j * spielerListe.feldAnzahl ] );
-                spieler->punkte = spielerListe.values[ 2 + j * spielerListe.feldAnzahl ];
-                if( sts->spielerFarbe->hat( (int)spielerListe.values[ 4 + j * spielerListe.feldAnzahl ] - 1 ) )
-                    spieler->farbe = sts->spielerFarbe->get( (int)spielerListe.values[ 4 + j * spielerListe.feldAnzahl ] - 1 );
-                else
-                    spieler->farbe = 0;
-                switch( (int)spielerListe.values[ 3 + j * spielerListe.feldAnzahl ] )
-                {
-                case 1:
-                    spieler->status->setText( "Verloren" );
-                    break;
-                case 2:
-                    spieler->status->setText( "Gewonnen" );
-                    break;
-                case 3:
-                    spieler->status->setText( "Nicht Anwesend" );
-                    break;
-                case 4:
-                    spieler->status->setText( "Beobachter" );
-                    break;
-                case 5:
-                    spieler->status->setText( "Unentschieden" );
-                    break;
-                }
-                spiel->teams->z( index )->sAnzahl++;
-                spiel->teams->z( index )->spieler->add( spieler );
-            }
-        }
-        else
-            unlock();
-        sts->release();
-        ret->spiele->add( spiel );
-    }
-    return ret;
+	Text* befehl = new Text("SELECT a.id, a.karte_id, c.name, d.name, substring( a.beginn_datum::CHARACTER VARYING FOR 16 ), "
+		"b.spiel_spieler_status_id, a.spiel_status_id, count( e.spiel_id ) "
+		"FROM spiel a, spiel_spieler b, spiel_art c, karte d, (SELECT spiel_id FROM spiel_spieler) e "
+		"WHERE a.id = e.spiel_id AND a.karte_id = d.id AND d.spiel_art_id = c.id "
+		"AND a.id = b.spiel_id AND b.account_id = ");
+	*befehl += accountId;
+	*befehl += " GROUP BY a.id, a.karte_id, c.name, d.name, a.beginn_datum, b.spiel_spieler_status_id, a.spiel_status_id "
+		"ORDER BY beginn_datum DESC LIMIT 20";
+	lock();
+	if (!datenbank->befehl(*befehl))
+	{
+		unlock();
+		befehl->release();
+		return 0;
+	}
+	Result spielListe = datenbank->getResult();
+	unlock();
+	AHDaten* ret = new AHDaten();
+	for (int i = 0; i < spielListe.zeilenAnzahl; i++)
+	{
+		SpielerTeamStruktur* sts = new SpielerTeamStruktur();
+		bool stsOK = 1;
+		KartenLeser* reader = new KartenLeser((int)spielListe.values[1 + i * spielListe.feldAnzahl], is);
+		if (!reader->ladeSpielerTeamStruktur(sts))
+			stsOK = 0;
+		reader->release();
+		AHSpielDaten* spiel = new AHSpielDaten();
+		spiel->id = (int)spielListe.values[i * spielListe.feldAnzahl];
+		spiel->karteId = (int)spielListe.values[1 + i * spielListe.feldAnzahl];
+		spiel->spiel->setText(spielListe.values[2 + i * spielListe.feldAnzahl]);
+		spiel->karte->setText(spielListe.values[3 + i * spielListe.feldAnzahl]);
+		spiel->datum->setText(spielListe.values[4 + i * spielListe.feldAnzahl]);
+		switch ((int)spielListe.values[5 + i * spielListe.feldAnzahl])
+		{
+		case 1:
+			spiel->status->setText("Verloren");
+			break;
+		case 2:
+			spiel->status->setText("Gewonnen");
+			break;
+		case 3:
+			spiel->status->setText("Nicht Anwesend");
+			break;
+		case 4:
+			spiel->status->setText("Beobachter");
+			break;
+		case 5:
+			spiel->status->setText("Unentschieden");
+			break;
+		}
+		switch ((int)spielListe.values[6 + i * spielListe.feldAnzahl])
+		{
+		case 1:
+			spiel->spielStatus->setText("Beginnt");
+			break;
+		case 2:
+			spiel->spielStatus->setText("Läuft");
+			break;
+		case 3:
+			spiel->spielStatus->setText("Abgebrochen");
+			break;
+		case 4:
+			spiel->spielStatus->setText("Fehlerhaft");
+			break;
+		case 5:
+			spiel->spielStatus->setText("Beendet");
+			break;
+		case 6:
+			spiel->spielStatus->setText("Unbewertet");
+			break;
+		}
+		spiel->sAnzahl = (int)spielListe.values[7 + i * spielListe.feldAnzahl];
+		*befehl = "SELECT substring( (end_datum - beginn_datum)::CHARACTER VARYING FOR 8) FROM spiel WHERE id = ";
+		*befehl += spielListe.values[i * spielListe.feldAnzahl].getText();
+		lock();
+		if (datenbank->befehl(*befehl))
+		{
+			Result dauer = datenbank->getResult();
+			unlock();
+			if (dauer.zeilenAnzahl && dauer.values[0].getLength())
+				spiel->dauer->setText(dauer.values[0]);
+		}
+		else
+			unlock();
+		int gewinnerTeam = -1;
+		if (stsOK)
+		{
+			*befehl = "SELECT team_id FROM spiel_spieler WHERE spiel_spieler_status_id = 2 AND spiel_id = ";
+			*befehl += spielListe.values[i * spielListe.feldAnzahl].getText();
+			lock();
+			if (datenbank->befehl(*befehl))
+			{
+				Result team = datenbank->getResult();
+				unlock();
+				if (team.zeilenAnzahl && team.values[0].getLength() && sts->teamName->z((int)team.values[0]))
+				{
+					spiel->gewinner->setText(sts->teamName->z((int)team.values[0])->getText());
+					gewinnerTeam = (int)team.values[0];
+				}
+			}
+			else
+				unlock();
+		}
+		*befehl = "SELECT a.ruf_name, b.team_id, b.punkte, b.spiel_spieler_status_id, b.spieler_nummer FROM account a, spiel_spieler b WHERE b.account_id = a.id AND spiel_id = ";
+		*befehl += spielListe.values[i * spielListe.feldAnzahl].getText();
+		*befehl += " ORDER BY team_id";
+		lock();
+		if (datenbank->befehl(*befehl))
+		{
+			Result spielerListe = datenbank->getResult();
+			unlock();
+			for (int j = 0; j < spielerListe.zeilenAnzahl; j++)
+			{
+				int tAnz = spiel->teams->getEintragAnzahl();
+				int index = -1;
+				for (int k = 0; k < tAnz; k++)
+				{
+					if (spiel->teams->z(k)->id == (int)spielerListe.values[1 + j * spielerListe.feldAnzahl])
+					{
+						index = k;
+						break;
+					}
+				}
+				if (index < 0)
+				{
+					index = tAnz;
+					AHSpielTeamDaten* team = new AHSpielTeamDaten();
+					team->id = (int)spielerListe.values[1 + j * spielerListe.feldAnzahl];
+					if (sts->teamName->z(team->id))
+						team->name->setText(sts->teamName->z(team->id)->getText());
+					team->sAnzahl = 0;
+					if (team->id == gewinnerTeam)
+						team->status->setText("Gewonnen");
+					else
+						team->status->setText("Verloren");
+					if (sts->teamFarbe->hat(team->id))
+						team->farbe = sts->teamFarbe->get(team->id);
+					else
+						team->farbe = 0;
+					spiel->teams->add(team);
+				}
+				AHSpielSpielerDaten* spieler = new AHSpielSpielerDaten();
+				spieler->name->setText(spielerListe.values[j * spielerListe.feldAnzahl]);
+				spieler->punkte = (int)spielerListe.values[2 + j * spielerListe.feldAnzahl];
+				if (sts->spielerFarbe->hat((int)spielerListe.values[4 + j * spielerListe.feldAnzahl] - 1))
+					spieler->farbe = sts->spielerFarbe->get((int)spielerListe.values[4 + j * spielerListe.feldAnzahl] - 1);
+				else
+					spieler->farbe = 0;
+				switch ((int)spielerListe.values[3 + j * spielerListe.feldAnzahl])
+				{
+				case 1:
+					spieler->status->setText("Verloren");
+					break;
+				case 2:
+					spieler->status->setText("Gewonnen");
+					break;
+				case 3:
+					spieler->status->setText("Nicht Anwesend");
+					break;
+				case 4:
+					spieler->status->setText("Beobachter");
+					break;
+				case 5:
+					spieler->status->setText("Unentschieden");
+					break;
+				}
+				spiel->teams->z(index)->sAnzahl++;
+				spiel->teams->z(index)->spieler->add(spieler);
+			}
+		}
+		else
+			unlock();
+		sts->release();
+		ret->spiele->add(spiel);
+	}
+	return ret;
 }
 
-bool ISDatenbank::getHistorieServerPortIp( int clientId, int spielId, int *port, Text *ip )
+bool ISDatenbank::getHistorieServerPortIp(int clientId, int spielId, int* port, Text* ip)
 {
-    lock();
-    if( !datenbank->befehl( Text( "SELECT a.id, a.port, a.ip FROM server a, server_historie_spiel b "
-                                  "WHERE a.id = b.server_historie_id AND a.tasks < a.max_tasks - 1 AND "
-                                  "a.server_status_id = 3 AND b.spiel_id = " ) += spielId ) )
-    {
-        unlock();
-        return 0;
-    }
-    Result res = datenbank->getResult();
-    unlock();
-    if( !res.zeilenAnzahl )
-    {
-        res.destroy();
-        return 0;
-    }
-    int id = res.values[ 0 ];
-    *port = res.values[ 1 ];
-    *ip = res.values[ 2 ].getText();
-    res.destroy();
-    Text *befehl = new Text( "INSERT INTO server_client( client_id, server_id ) VALUES ( " );
-    befehl->append( clientId );
-    befehl->append( ", " );
-    befehl->append( id );
-    befehl->append( " )" );
-    bool ret = 1;
-    lock();
-    ret &= datenbank->befehl( Text( "DELETE FROM server_client a USING server b WHERE b.server_typ_name = 'historie' AND b.id = a.server_id AND a.client_id = " ) += clientId );
-    ret &= datenbank->befehl( *befehl );
-    unlock();
-    befehl->release();
-    return ret;
+	lock();
+	if (!datenbank->befehl(Text("SELECT a.id, a.port, a.ip FROM server a, server_historie_spiel b "
+		"WHERE a.id = b.server_historie_id AND a.tasks < a.max_tasks - 1 AND "
+		"a.server_status_id = 3 AND b.spiel_id = ") += spielId))
+	{
+		unlock();
+		return 0;
+	}
+	Result res = datenbank->getResult();
+	unlock();
+	if (!res.zeilenAnzahl)
+	{
+		res.destroy();
+		return 0;
+	}
+	int id = (int)res.values[0];
+	*port = (int)res.values[1];
+	*ip = res.values[2].getText();
+	res.destroy();
+	Text* befehl = new Text("INSERT INTO server_client( client_id, server_id ) VALUES ( ");
+	befehl->append(clientId);
+	befehl->append(", ");
+	befehl->append(id);
+	befehl->append(" )");
+	bool ret = 1;
+	lock();
+	ret &= datenbank->befehl(Text("DELETE FROM server_client a USING server b WHERE b.server_typ_name = 'historie' AND b.id = a.server_id AND a.client_id = ") += clientId);
+	ret &= datenbank->befehl(*befehl);
+	unlock();
+	befehl->release();
+	return ret;
 }
 
-bool ISDatenbank::hatKlientRecht( int kId, int recht )
+bool ISDatenbank::hatKlientRecht(int kId, int recht)
 {
-    Text befehl = "SELECT a.* FROM account_user_rechte a, account_client b WHERE a.account_id = b.account_id AND b.client_id = ";
-    befehl += kId;
-    befehl += " AND a.user_rechte_id = ";
-    befehl += recht;
-    lock();
-    datenbank->befehl( befehl );
-    int num = datenbank->getZeilenAnzahl();
-    unlock();
-    return num == 1;
+	Text befehl = "SELECT a.* FROM account_user_rechte a, account_client b WHERE a.account_id = b.account_id AND b.client_id = ";
+	befehl += kId;
+	befehl += " AND a.user_rechte_id = ";
+	befehl += recht;
+	lock();
+	datenbank->befehl(befehl);
+	int num = datenbank->getZeilenAnzahl();
+	unlock();
+	return num == 1;
 }
 
-Result ISDatenbank::getKartenListe( int kId, char *suchFilter, char sortSpalte, char sortRichtung )
+Result ISDatenbank::getKartenListe(int kId, const char* suchFilter, char sortSpalte, char sortRichtung)
 {
-    Text befehl = "SELECT a.id, a.name, b.name, c.kupfer, a.verkauft, a.max_spieler FROM karte a ";
-    befehl += "INNER JOIN spiel_art b ON a.spiel_art_id = b.id ";
-    befehl += "LEFT JOIN karte_kauf_erlaubt c ON a.id = c.karte_id ";
-    befehl += "INNER JOIN account_client d ON d.account_id = a.account_id ";
-    befehl += "WHERE d.client_id = ";
-    befehl += kId;
-    befehl += " AND a.name LIKE'%";
-    befehl += suchFilter;
-    befehl += "%' ORDER BY ";
-    befehl += sortSpalte + 2;
-    if( sortRichtung ) // absteigend
-        befehl += " DESC";
-    lock();
-    if( !datenbank->befehl( befehl ) )
-    {
-        unlock();
-        Result res = { 0, 0, 0, 0 };
-        return res;
-    }
-    Result res = datenbank->getResult();
-    unlock();
-    return res;
+	Text befehl = "SELECT a.id, a.name, b.name, c.kupfer, a.verkauft, a.max_spieler FROM karte a ";
+	befehl += "INNER JOIN spiel_art b ON a.spiel_art_id = b.id ";
+	befehl += "LEFT JOIN karte_kauf_erlaubt c ON a.id = c.karte_id ";
+	befehl += "INNER JOIN account_client d ON d.account_id = a.account_id ";
+	befehl += "WHERE d.client_id = ";
+	befehl += kId;
+	befehl += " AND a.name LIKE'%";
+	befehl += suchFilter;
+	befehl += "%' ORDER BY ";
+	befehl += sortSpalte + 2;
+	if (sortRichtung) // absteigend
+		befehl += " DESC";
+	lock();
+	if (!datenbank->befehl(befehl))
+	{
+		unlock();
+		Result res = { 0, 0, 0, 0 };
+		return res;
+	}
+	Result res = datenbank->getResult();
+	unlock();
+	return res;
 }
 
-bool ISDatenbank::getEditorServerPortIp( int clientId, int karteId, int *port, Text *ip )
+bool ISDatenbank::getEditorServerPortIp(int clientId, int karteId, int* port, Text* ip)
 {
-    Text befehl = "SELECT a.port, a.ip, a.id FROM server a, karte b, account_client c ";
-    befehl += "WHERE a.id = b.server_editor_id AND b.account_id = c.account_id AND a.server_status_id = 3 AND c.client_id = ";
-    befehl += clientId;
-    befehl += " AND b.id = ";
-    befehl += karteId;
-    lock();
-    if( !datenbank->befehl( befehl ) )
-    {
-        unlock();
-        return 0;
-    }
-    Result res = datenbank->getResult();
-    unlock();
-    *port = res.values[ 0 ];
-    ip->setText( res.values[ 1 ] );
-    int id = res.values[ 2 ];
-    res.destroy();
-    befehl = "INSERT INTO server_client( client_id, server_id ) VALUES ( ";
-    befehl += clientId;
-    befehl += ", ";
-    befehl += id;
-    befehl += " )";
-    bool ret = 1;
-    lock();
-    ret &= datenbank->befehl( Text( "SELECT a.server_id FROM server_client a, server b WHERE a.server_id = b.id AND b.server_typ_name = 'editor' AND a.client_id = " ) += clientId );
-    ret &= datenbank->befehl( Text( "DELETE FROM server_client a USING server b WHERE b.id = a.server_id AND b.server_typ_name = 'editor' AND a.client_id = " ) += clientId );
-    ret &= datenbank->befehl( befehl );
-    unlock();
-    return 1;
+	Text befehl = "SELECT a.port, a.ip, a.id FROM server a, karte b, account_client c ";
+	befehl += "WHERE a.id = b.server_editor_id AND b.account_id = c.account_id AND a.server_status_id = 3 AND c.client_id = ";
+	befehl += clientId;
+	befehl += " AND b.id = ";
+	befehl += karteId;
+	lock();
+	if (!datenbank->befehl(befehl))
+	{
+		unlock();
+		return 0;
+	}
+	Result res = datenbank->getResult();
+	unlock();
+	*port = (int)res.values[0];
+	ip->setText(res.values[1]);
+	int id = (int)res.values[2];
+	res.destroy();
+	befehl = "INSERT INTO server_client( client_id, server_id ) VALUES ( ";
+	befehl += clientId;
+	befehl += ", ";
+	befehl += id;
+	befehl += " )";
+	bool ret = 1;
+	lock();
+	ret &= datenbank->befehl(Text("SELECT a.server_id FROM server_client a, server b WHERE a.server_id = b.id AND b.server_typ_name = 'editor' AND a.client_id = ") += clientId);
+	ret &= datenbank->befehl(Text("DELETE FROM server_client a USING server b WHERE b.id = a.server_id AND b.server_typ_name = 'editor' AND a.client_id = ") += clientId);
+	ret &= datenbank->befehl(befehl);
+	unlock();
+	return 1;
 }
 
-bool ISDatenbank::getKartenServerPortIp( int clientId, int karteId, int *port, Text *ip )
+bool ISDatenbank::getKartenServerPortIp(int clientId, int karteId, int* port, Text* ip)
 {
-    Text befehl = "SELECT a.port, a.ip, a.id FROM server a, karte b ";
-    befehl += "WHERE a.id = b.server_karten_id AND a.server_status_id = 3 AND b.id = ";
-    befehl += karteId;
-    if( !karteId )
-        befehl = "SELECT port, ip, id FROM server WHERE server_typ_name = 'karten' AND server_status_id = 3 LIMIT 1";
-    lock();
-    if( !datenbank->befehl( befehl ) )
-    {
-        unlock();
-        return 0;
-    }
-    Result res = datenbank->getResult();
-    unlock();
-    if( !res.zeilenAnzahl )
-        return 0;
-    *port = res.values[ 0 ];
-    ip->setText( res.values[ 1 ] );
-    int id = res.values[ 2 ];
-    res.destroy();
-    if( clientId )
-    {
-        befehl = "INSERT INTO server_client( client_id, server_id ) VALUES ( ";
-        befehl += clientId;
-        befehl += ", ";
-        befehl += id;
-        befehl += " )";
-        bool ret = 1;
-        lock();
-        ret &= datenbank->befehl( Text( "SELECT a.server_id FROM server_client a, server b WHERE b.id = a.server_id AND b.server_typ_name = 'karten' AND a.client_id = " ) += clientId );
-        ret &= datenbank->befehl( Text( "DELETE FROM server_client a USING server b WHERE b.id = a.server_id AND b.server_typ_name = 'karten' AND a.client_id = " ) += clientId );
-        ret &= datenbank->befehl( befehl );
-        unlock();
-    }
-    return 1;
+	Text befehl = "SELECT a.port, a.ip, a.id FROM server a, karte b ";
+	befehl += "WHERE a.id = b.server_karten_id AND a.server_status_id = 3 AND b.id = ";
+	befehl += karteId;
+	if (!karteId)
+		befehl = "SELECT port, ip, id FROM server WHERE server_typ_name = 'karten' AND server_status_id = 3 LIMIT 1";
+	lock();
+	if (!datenbank->befehl(befehl))
+	{
+		unlock();
+		return 0;
+	}
+	Result res = datenbank->getResult();
+	unlock();
+	if (!res.zeilenAnzahl)
+		return 0;
+	*port = (int)res.values[0];
+	ip->setText(res.values[1]);
+	int id = (int)res.values[2];
+	res.destroy();
+	if (clientId)
+	{
+		befehl = "INSERT INTO server_client( client_id, server_id ) VALUES ( ";
+		befehl += clientId;
+		befehl += ", ";
+		befehl += id;
+		befehl += " )";
+		bool ret = 1;
+		lock();
+		ret &= datenbank->befehl(Text("SELECT a.server_id FROM server_client a, server b WHERE b.id = a.server_id AND b.server_typ_name = 'karten' AND a.client_id = ") += clientId);
+		ret &= datenbank->befehl(Text("DELETE FROM server_client a USING server b WHERE b.id = a.server_id AND b.server_typ_name = 'karten' AND a.client_id = ") += clientId);
+		ret &= datenbank->befehl(befehl);
+		unlock();
+	}
+	return 1;
 }
 
 // constant
-Text *ISDatenbank::getLetzterFehler() const
+Text* ISDatenbank::getLetzterFehler() const
 {
-    return datenbank->getLetzterFehler();
+	return datenbank->getLetzterFehler();
 }

InformationServer/Datenbank.h

@@ -11,10 +11,10 @@ using namespace sql;
 
 namespace Admin_Recht
 {
-    const int ISStarten = 20;
-    const int ISBeenden = 21;
-    const int ISPausieren = 22;
-    const int ISMCChange = 23;
+	const int ISStarten = 20;
+	const int ISBeenden = 21;
+	const int ISPausieren = 22;
+	const int ISMCChange = 23;
 }
 
 struct AHDaten;
@@ -23,73 +23,73 @@ class InformationServer;
 class ISDatenbank : public virtual ReferenceCounter
 {
 private:
-    Datenbank *datenbank;
-    CRITICAL_SECTION cs;
+	Datenbank* datenbank;
+	CRITICAL_SECTION cs;
 
 public:
-    // Konstruktor
-    ISDatenbank( InitDatei *zIni );
-    // Destruktor
-    ~ISDatenbank();
-    // nicht constant
-    void lock();
-    void unlock();
-    int istAdministrator( const char *name, const char *passwort );
-    bool adminHatRecht( int id, int recht );
-    bool proveKlient( int num, int sNum );
-    Text *getKlientKey( int cId );
-    void unregisterKlient( int num, int sNum );
-    bool setServerStatus( int id, int status );
-    bool setMaxClients( int id, int maxC );
-    bool serverIstNichtPausiert( int id );
-    Text *getInformationsText( char *typ );
-    bool istSpielErlaubt( int spielId );
-    bool istKarteErlaubt( int karteId );
-    Text *getAccountRufName( int accountId );
-    int getAccountId( char *rufName );
-    Array< int > *getAccountSpielStatistik( int accountId, int spielId );
-    int getAccountKarteSpiele( int accountId, int karteId );
-    int getAccountKarteSpieleGewonnen( int accountId, int karteId );
-    Text *getKarteName( int karteId );
-    Text *getSpielName( int spielId );
-    Text *getChatroomName( int chatroomId );
-    int getChatroomId( char *name );
-    int getSpielId( int karteId );
-    int getSpielId( char *name );
-    int getKarteId( char *name );
-    int getGruppenKarteId( int gruppeId );
-    int getGruppeAdminId( int gruppeId );
-    int getSpielerPunkte( int spielId, int accountId );
-    Array< int > *getAccountSpielArtListe( int cId );
-    int getNeusteSpielVersion( int spielId );
-    int getKupfer( int cId );
-    int getDateiGruppeVonSpiel( int sId );
-    Text *getDateiGruppePfad( int dgId );
-    Array< int > *getAccountKarteListe( int cId, int kId );
-    bool hatAccountKarte( int account, int karte );
-    bool hatAccountSpiel( int account, int spiel );
-    int getDateiGruppeVonPfad( char *pfad );
-    int getNeusteDateiGruppe( int dg );
-    bool getGruppeSpielerAdd( int gruppeId );
-    Result getSpielerListe( char *suche, int *seite, int *maxSeite, int sortStalte, bool backwords );
-    bool getSpielerAktivity( int accountId, RCArray< Text > *datum, Array< double > *stOnline, Array< double > *stGespielt,
-                             Array< int > *anzSpiele, Array< int > *anzGewonnen );
-    int getOnlineSeconds( int accountId, char *beg, char *end );
-    int getGespieltSeconds( int accountId, char *beg, char *end );
-    int getGespieltSpiele( int accountId, char *beg, char *end );
-    int getGewonnenSpiele( int accountId, char *beg, char *end );
-    Array< int > *getAccountKarteGespieltListe( int accountId, int spielArt );
-    Array< int > *getAccountSpielGespieltListe( int accountId );
-    Result getSpielPartnerListe( int accountId );
-    Result getSpielStatistikListe( int accountId, int *seite, int *maxSeite, int sortStalte, bool backwords );
-    AHDaten *getSpielHistorie( int accountId, InformationServer *is );
-    bool getHistorieServerPortIp( int clientId, int spielId, int *port, Text *ip );
-    bool hatKlientRecht( int kId, int recht );
-    Result getKartenListe( int kId, char *suchFilter, char sortSpalte, char sortRichtung );
-    bool getEditorServerPortIp( int clientId, int karteId, int *port, Text *ip );
-    bool getKartenServerPortIp( int clientId, int karteId, int *port, Text *ip );
-    // constant
-    Text *getLetzterFehler() const;
+	// Konstruktor
+	ISDatenbank(InitDatei* zIni);
+	// Destruktor
+	~ISDatenbank();
+	// nicht constant
+	void lock();
+	void unlock();
+	int istAdministrator(const char* name, const char* passwort);
+	bool adminHatRecht(int id, int recht);
+	bool proveKlient(int num, int sNum);
+	Text* getKlientKey(int cId);
+	void unregisterKlient(int num, int sNum);
+	bool setServerStatus(int id, int status);
+	bool setMaxClients(int id, int maxC);
+	bool serverIstNichtPausiert(int id);
+	Text* getInformationsText(char* typ);
+	bool istSpielErlaubt(int spielId);
+	bool istKarteErlaubt(int karteId);
+	Text* getAccountRufName(int accountId);
+	int getAccountId(const char* rufName);
+	Array< int >* getAccountSpielStatistik(int accountId, int spielId);
+	int getAccountKarteSpiele(int accountId, int karteId);
+	int getAccountKarteSpieleGewonnen(int accountId, int karteId);
+	Text* getKarteName(int karteId);
+	Text* getSpielName(int spielId);
+	Text* getChatroomName(int chatroomId);
+	int getChatroomId(const char* name);
+	int getSpielId(int karteId);
+	int getSpielId(const char* name);
+	int getKarteId(const char* name);
+	int getGruppenKarteId(int gruppeId);
+	int getGruppeAdminId(int gruppeId);
+	int getSpielerPunkte(int spielId, int accountId);
+	Array< int >* getAccountSpielArtListe(int cId);
+	int getNeusteSpielVersion(int spielId);
+	int getKupfer(int cId);
+	int getDateiGruppeVonSpiel(int sId);
+	Text* getDateiGruppePfad(int dgId);
+	Array< int >* getAccountKarteListe(int cId, int kId);
+	bool hatAccountKarte(int account, int karte);
+	bool hatAccountSpiel(int account, int spiel);
+	int getDateiGruppeVonPfad(const char* pfad);
+	int getNeusteDateiGruppe(int dg);
+	bool getGruppeSpielerAdd(int gruppeId);
+	Result getSpielerListe(const char* suche, int* seite, int* maxSeite, int sortStalte, bool backwords);
+	bool getSpielerAktivity(int accountId, RCArray< Text >* datum, Array< double >* stOnline, Array< double >* stGespielt,
+		Array< int >* anzSpiele, Array< int >* anzGewonnen);
+	int getOnlineSeconds(int accountId, const char* beg, const char* end);
+	int getGespieltSeconds(int accountId, const char* beg, const char* end);
+	int getGespieltSpiele(int accountId, const char* beg, const char* end);
+	int getGewonnenSpiele(int accountId, const  char* beg, const char* end);
+	Array< int >* getAccountKarteGespieltListe(int accountId, int spielArt);
+	Array< int >* getAccountSpielGespieltListe(int accountId);
+	Result getSpielPartnerListe(int accountId);
+	Result getSpielStatistikListe(int accountId, int* seite, int* maxSeite, int sortStalte, bool backwords);
+	AHDaten* getSpielHistorie(int accountId, InformationServer* is);
+	bool getHistorieServerPortIp(int clientId, int spielId, int* port, Text* ip);
+	bool hatKlientRecht(int kId, int recht);
+	Result getKartenListe(int kId, const char* suchFilter, char sortSpalte, char sortRichtung);
+	bool getEditorServerPortIp(int clientId, int karteId, int* port, Text* ip);
+	bool getKartenServerPortIp(int clientId, int karteId, int* port, Text* ip);
+	// constant
+	Text* getLetzterFehler() const;
 };
 
 #endif

InformationServer/InformationServer.cpp

@@ -6,1643 +6,1643 @@
 
 // Inhalt der InformationServer Klasse aus InformationServer.h
 // Konstruktor 
-InformationServer::InformationServer( InitDatei* zIni )
-    : Thread()
+InformationServer::InformationServer(InitDatei* zIni)
+	: Thread()
 {
-    Network::Start( 100 );
-    std::cout << "IS: Verbindung mit Datenbank wird hergestellt...\n";
-    db = new ISDatenbank( zIni );
-    klients = new RCArray< ISKlient >();
-    empfangen = 0;
-    gesendet = 0;
-    fehler = new Text();
-    ini = dynamic_cast<InitDatei*>(zIni->getThis());
-    id = *zIni->zWert( "ServerId" );
-    server = new Server();
-    aServer = new SSLServer();
-    aServer->setPrivateKeyPassword( zIni->zWert( "SSLPasswort" )->getText() );
-    aServer->setCertificateFile( zIni->zWert( "SSLCert" )->getText() );
-    aServer->setPrivateKeyFile( zIni->zWert( "SSLKey" )->getText() );
-    std::cout << "IS: Starten des Admin Servers...\n";
-    if( !aServer->verbinde( (unsigned short)TextZuInt( ini->zWert( "AdminServerPort" )->getText(), 10 ), 10 ) )
-    {
-        std::cout << "IS: Der Admin Server konnte nicht gestartet werden. Das Programm wird beendet.\n";
-        exit( 1 );
-    }
-    db->setServerStatus( id, 2 );
-    end = 0;
-    nichtPausiert = 0;
-    InitializeCriticalSection( &cs );
-    if( zIni->zWert( "Aktiv" )->istGleich( "TRUE" ) )
-    {
-        serverStarten();
-        serverFortsetzen();
-    }
+	Network::Start(100);
+	std::cout << "IS: Verbindung mit Datenbank wird hergestellt...\n";
+	db = new ISDatenbank(zIni);
+	klients = new RCArray< ISKlient >();
+	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 << "IS: Starten des Admin Servers...\n";
+	if (!aServer->verbinde((unsigned short)TextZuInt(ini->zWert("AdminServerPort")->getText(), 10), 10))
+	{
+		std::cout << "IS: Der Admin Server konnte nicht gestartet werden. Das Programm wird beendet.\n";
+		exit(1);
+	}
+	db->setServerStatus(id, 2);
+	end = 0;
+	nichtPausiert = 0;
+	InitializeCriticalSection(&cs);
+	if (zIni->zWert("Aktiv")->istGleich("TRUE"))
+	{
+		serverStarten();
+		serverFortsetzen();
+	}
 }
 
 // Destruktor 
 InformationServer::~InformationServer()
 {
-    fehler->release();
-    server->trenne();
-    server->release();
-    aServer->trenne();
-    aServer->release();
-    if( klients )
-        klients->release();
-    ini->release();
-    db->release();
-    DeleteCriticalSection( &cs );
+	fehler->release();
+	server->trenne();
+	server->release();
+	aServer->trenne();
+	aServer->release();
+	if (klients)
+		klients->release();
+	ini->release();
+	db->release();
+	DeleteCriticalSection(&cs);
 }
 
 // nicht constant 
 void InformationServer::runn()
 {
-    while( !end && aServer->isConnected() )
-    {
-        SSLSKlient* klient;
-        klient = aServer->getKlient();
-        if( end && klient )
-        {
-            klient->trenne();
-            klient = (SSLSKlient*)klient->release();
-            Sleep( 1000 );
-            return;
-        }
-        if( !klient )
-            continue;
-        ISAKlient* clHandle = new ISAKlient( klient, dynamic_cast<InformationServer*>(getThis()) );
-        clHandle->start();
-    }
+	while (!end && aServer->isConnected())
+	{
+		SSLSKlient* klient;
+		klient = aServer->getKlient();
+		if (end && klient)
+		{
+			klient->trenne();
+			klient = (SSLSKlient*)klient->release();
+			Sleep(1000);
+			return;
+		}
+		if (!klient)
+			continue;
+		ISAKlient* clHandle = new ISAKlient(klient, dynamic_cast<InformationServer*>(getThis()));
+		clHandle->start();
+	}
 }
 
 void InformationServer::thread()
 {
-    while( server->isConnected() )
-    {
-        SKlient* klient;
-        klient = server->getKlient();
-        if( !klient )
-            continue;
-        Framework::getThreadRegister()->cleanUpClosedThreads();
-        ISKlient* clHandle = new ISKlient( klient, dynamic_cast<InformationServer*>(getThis()) );
-        EnterCriticalSection( &cs );
-        klients->add( clHandle );
-        LeaveCriticalSection( &cs );
-        clHandle->start();
-    }
+	while (server->isConnected())
+	{
+		SKlient* klient;
+		klient = server->getKlient();
+		if (!klient)
+			continue;
+		Framework::getThreadRegister()->cleanUpClosedThreads();
+		ISKlient* clHandle = new ISKlient(klient, dynamic_cast<InformationServer*>(getThis()));
+		EnterCriticalSection(&cs);
+		klients->add(clHandle);
+		LeaveCriticalSection(&cs);
+		clHandle->start();
+	}
 }
 
 void InformationServer::close()
 {
-    db->setServerStatus( id, 1 );
-    server->trenne();
+	db->setServerStatus(id, 1);
+	server->trenne();
 #ifdef WIN32
-    warteAufThread( 1000 );
+	warteAufThread(1000);
 #endif
-    EnterCriticalSection( &cs );
-    for( int i = 0; i < klients->getEintragAnzahl(); i++ )
-        klients->z( i )->absturz();
-    klients = (RCArray<ISKlient>*)klients->release();
-    LeaveCriticalSection( &cs );
-    ende();
-    run = 0;
-    end = 1;
-    Klient* klient = new Klient();
-    klient->verbinde( aServer->getPort(), "127.0.0.1" );
-    Sleep( 500 );
-    aServer->trenne();
-    klient->release();
+	EnterCriticalSection(&cs);
+	for (int i = 0; i < klients->getEintragAnzahl(); i++)
+		klients->z(i)->absturz();
+	klients = (RCArray<ISKlient>*)klients->release();
+	LeaveCriticalSection(&cs);
+	ende();
+	run = 0;
+	end = 1;
+	Klient* klient = new Klient();
+	klient->verbinde(aServer->getPort(), "127.0.0.1");
+	Sleep(500);
+	aServer->trenne();
+	klient->release();
 }
 
 bool InformationServer::serverStarten()
 {
-    if( nichtPausiert )
-    {
-        fehler->setText( "Der Server konnte nicht gestartet werden: Der Server läuft bereits." );
-        return 0;
-    }
-    if( server )
-        server->release();
-    server = new Server();
-    if( server->verbinde( (unsigned short)TextZuInt( ini->zWert( "ServerPort" )->getText(), 10 ), 10 ) )
-    {
-        nichtPausiert = 1;
-        start();
-        return 1;
-    }
-    else
-    {
-        serverBeenden();
-        fehler->setText( "Der Server konnte nicht gestartet werden: Eventuell ist der Port in benutzung." );
-        return 0;
-    }
+	if (nichtPausiert)
+	{
+		fehler->setText("Der Server konnte nicht gestartet werden: Der Server läuft bereits.");
+		return 0;
+	}
+	if (server)
+		server->release();
+	server = new Server();
+	if (server->verbinde((unsigned short)TextZuInt(ini->zWert("ServerPort")->getText(), 10), 10))
+	{
+		nichtPausiert = 1;
+		start();
+		return 1;
+	}
+	else
+	{
+		serverBeenden();
+		fehler->setText("Der Server konnte nicht gestartet werden: Eventuell ist der Port in benutzung.");
+		return 0;
+	}
 }
 
 bool InformationServer::serverPause()
 {
-    if( !nichtPausiert )
-    {
-        fehler->setText( "Der Server konnte nicht pausiert werden: Der Server läuft nicht." );
-        return 0;
-    }
-    if( !db->setServerStatus( id, 2 ) )
-    {
-        fehler->setText( "Der Server konnte nicht pausiert werden: " );
-        fehler->append( db->getLetzterFehler() );
-        return 0;
-    }
-    return 1;
+	if (!nichtPausiert)
+	{
+		fehler->setText("Der Server konnte nicht pausiert werden: Der Server läuft nicht.");
+		return 0;
+	}
+	if (!db->setServerStatus(id, 2))
+	{
+		fehler->setText("Der Server konnte nicht pausiert werden: ");
+		fehler->append(db->getLetzterFehler());
+		return 0;
+	}
+	return 1;
 }
 
 bool InformationServer::serverFortsetzen()
 {
-    if( !nichtPausiert )
-    {
-        fehler->setText( "Der Server konnte nicht fortgesetzt werden: Der Server läuft nicht." );
-        return 0;
-    }
-    if( !db->setServerStatus( id, 3 ) )
-    {
-        fehler->setText( "Der Server konnte nicht fortgesetzt werden: " );
-        fehler->append( db->getLetzterFehler() );
-        return 0;
-    }
-    return 1;
+	if (!nichtPausiert)
+	{
+		fehler->setText("Der Server konnte nicht fortgesetzt werden: Der Server läuft nicht.");
+		return 0;
+	}
+	if (!db->setServerStatus(id, 3))
+	{
+		fehler->setText("Der Server konnte nicht fortgesetzt werden: ");
+		fehler->append(db->getLetzterFehler());
+		return 0;
+	}
+	return 1;
 }
 
 bool InformationServer::serverBeenden()
 {
-    if( !nichtPausiert )
-    {
-        fehler->setText( "Der Server konnte nicht beendet werden: Der Server läuft nicht." );
-        return 0;
-    }
-    if( db->serverIstNichtPausiert( id ) )
-    {
-        fehler->setText( "Der Server konnte nicht beendet werden: Der Server muss erst pausiert werden." );
-        return 0;
-    }
-    nichtPausiert = 0;
-    ende();
-    if( server )
-        server->trenne();
-    return 1;
+	if (!nichtPausiert)
+	{
+		fehler->setText("Der Server konnte nicht beendet werden: Der Server läuft nicht.");
+		return 0;
+	}
+	if (db->serverIstNichtPausiert(id))
+	{
+		fehler->setText("Der Server konnte nicht beendet werden: Der Server muss erst pausiert werden.");
+		return 0;
+	}
+	nichtPausiert = 0;
+	ende();
+	if (server)
+		server->trenne();
+	return 1;
 }
 
-bool InformationServer::setMaxKlients( int mc )
+bool InformationServer::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;
+	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 InformationServer::absturzKlient( int klientId )
+bool InformationServer::absturzKlient(int klientId)
 {
-    bool gefunden = 0;
-    EnterCriticalSection( &cs );
-    for( int i = 0; i < klients->getEintragAnzahl(); i++ )
-    {
-        if( klients->z( i )->getKlientNummer() == klientId )
-        {
-            klients->z( i )->absturz();
-            klients->remove( i );
-            gefunden = 1;
-            break;
-        }
-    }
-    LeaveCriticalSection( &cs );
-    return gefunden;
+	bool gefunden = 0;
+	EnterCriticalSection(&cs);
+	for (int i = 0; i < klients->getEintragAnzahl(); i++)
+	{
+		if (klients->z(i)->getKlientNummer() == klientId)
+		{
+			klients->z(i)->absturz();
+			klients->remove(i);
+			gefunden = 1;
+			break;
+		}
+	}
+	LeaveCriticalSection(&cs);
+	return gefunden;
 }
 
-bool InformationServer::removeKlient( ISKlient* zKlient )
+bool InformationServer::removeKlient(ISKlient* zKlient)
 {
-    bool gefunden = 0;
-    EnterCriticalSection( &cs );
-    for( int i = 0; i < klients->getEintragAnzahl(); i++ )
-    {
-        if( klients->z( i ) == zKlient )
-        {
-            klients->remove( i );
-            gefunden = 1;
-            break;
-        }
-    }
-    LeaveCriticalSection( &cs );
-    return gefunden;
+	bool gefunden = 0;
+	EnterCriticalSection(&cs);
+	for (int i = 0; i < klients->getEintragAnzahl(); i++)
+	{
+		if (klients->z(i) == zKlient)
+		{
+			klients->remove(i);
+			gefunden = 1;
+			break;
+		}
+	}
+	LeaveCriticalSection(&cs);
+	return gefunden;
 }
 
-void InformationServer::addGesendet( int bytes )
+void InformationServer::addGesendet(int bytes)
 {
-    gesendet += bytes;
+	gesendet += bytes;
 }
 
-void InformationServer::addEmpfangen( int bytes )
+void InformationServer::addEmpfangen(int bytes)
 {
-    empfangen += bytes;
+	empfangen += bytes;
 }
 
 // constant 
 bool InformationServer::istAn() const
 {
-    return db->serverIstNichtPausiert( id );
+	return db->serverIstNichtPausiert(id);
 }
 
 Server* InformationServer::zServer() const
 {
-    return server;
+	return server;
 }
 
 ISDatenbank* InformationServer::zDB() const
 {
-    return db;
+	return db;
 }
 
 bool InformationServer::hatClients() const
 {
-    return klients->hat( 0 );
+	return klients->hat(0);
 }
 
 int InformationServer::getId() const
 {
-    return id;
+	return id;
 }
 
-char* InformationServer::getLetzterFehler() const
+const char* InformationServer::getLetzterFehler() const
 {
-    return fehler->getText();
+	return fehler->getText();
 }
 
 
 // Inhalt der ISAKlient Klasse aus InformationServer.h
 // Konstruktor 
-ISAKlient::ISAKlient( SSLSKlient* klient, InformationServer* is )
-    : Thread()
+ISAKlient::ISAKlient(SSLSKlient* klient, InformationServer* is)
+	: Thread()
 {
-    this->klient = klient;
-    name = new Text( "" );
-    passwort = new Text( "" );
-    adminId = 0;
-    this->is = is;
+	this->klient = klient;
+	name = new Text("");
+	passwort = new Text("");
+	adminId = 0;
+	this->is = is;
 }
 
 // Destruktor 
 ISAKlient::~ISAKlient()
 {
-    klient->trenne();
-    klient->release();
-    is->release();
-    name->release();
-    passwort->release();
+	klient->trenne();
+	klient->release();
+	is->release();
+	name->release();
+	passwort->release();
 }
 
 // nicht constant 
 void ISAKlient::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 = is->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( is->zDB()->adminHatRecht( adminId, Admin_Recht::ISStarten ) )
-                    {
-                        if( !is->serverStarten() )
-                        {
-                            Text* err = new Text();
-                            err->append( is->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( is->zDB()->adminHatRecht( adminId, Admin_Recht::ISBeenden ) )
-                    {
-                        if( is->serverBeenden() )
-                            klient->sende( "\1", 1 );
-                        else
-                        {
-                            Text* err = new Text();
-                            err->append( is->getLetzterFehler() );
-                            errorZuKlient( err->getText() );
-                            err->release();
-                        }
-                    }
-                    else
-                        errorZuKlient( "Du bist nicht berechtigt den Server zu beenden." );
-                }
-                break;
-            case 6: // Programm Schließen
-                if( !adminId )
-                    errorZuKlient( "Du musst dich einloggen." );
-                else
-                {
-                    bool ok = 0;
-                    if( is->isRunning() )
-                    {
-                        if( is->zDB()->adminHatRecht( adminId, Admin_Recht::ISBeenden ) )
-                        {
-                            if( is->serverBeenden() )
-                                ok = 1;
-                            else
-                            {
-                                Text* err = new Text();
-                                err->append( is->getLetzterFehler() );
-                                errorZuKlient( err->getText() );
-                                err->release();
-                            }
-                        }
-                        else
-                            errorZuKlient( "Du bist nicht berechtigt den Server zu beenden." );
-                    }
-                    else
-                        ok = 1;
-                    if( ok && is->hatClients() )
-                    {
-                        errorZuKlient( "Es sind noch Klients Online. Bitte versuche es später erneut." );
-                        break;
-                    }
-                    if( ok )
-                    {
-                        klient->sende( "\1", 1 );
-                        std::cout << "IS: Der Server wird von Benutzer " << adminId << " heruntergefahren.\n";
-                        is->close();
-                        br = 1;
-                    }
-                }
-                break;
-            case 7: // Progtamm abstürzen
-                if( !adminId )
-                    errorZuKlient( "Du musst dich einloggen." );
-                else
-                {
-                    bool ok = 0;
-                    if( is->isRunning() )
-                    {
-                        if( is->zDB()->adminHatRecht( adminId, Admin_Recht::ISBeenden ) )
-                        {
-                            is->serverBeenden();
-                            ok = 1;
-                        }
-                        else
-                            errorZuKlient( "Du bist nicht berechtigt den Server zu beenden." );
-                    }
-                    else
-                        ok = 1;
-                    if( ok )
-                    {
-                        klient->sende( "\1", 1 );
-                        std::cout << "IS: Der Server wurde von Benutzer " << adminId << " terminiert.\n";
-                        is->close();
-                        br = 1;
-                    }
-                }
-                break;
-            case 8: // Status Frage
-                if( 1 )
-                {
-                    char status = 0;
-                    if( is->isRunning() )
-                    {
-                        status = 1;
-                        if( is->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( is->zDB()->adminHatRecht( adminId, Admin_Recht::ISPausieren ) )
-                    {
-                        bool ok = 0;
-                        if( pause )
-                            ok = is->serverPause();
-                        else
-                            ok = is->serverFortsetzen();
-                        if( ok )
-                            klient->sende( "\1", 1 );
-                        else
-                        {
-                            Text* err = new Text();
-                            err->append( is->getLetzterFehler() );
-                            errorZuKlient( err->getText() );
-                            err->release();
-                        }
-                    }
-                    else
-                    {
-                        if( pause )
-                            errorZuKlient( "Du bist nicht berechtigt den Server zu pausieren." );
-                        else
-                            errorZuKlient( "Du bist nicht berechtigt den Server fortzusetzen." );
-                    }
-                }
-                break;
-            case 0xA: // maximale Anzahl der Clients setzen
-                if( !adminId )
-                    errorZuKlient( "Du musst dich einloggen." );
-                else
-                {
-                    klient->sende( "\1", 1 );
-                    int maxC = 0;
-                    klient->getNachricht( (char*)&maxC, 4 );
-                    if( is->zDB()->adminHatRecht( adminId, Admin_Recht::ISMCChange ) )
-                    {
-                        if( is->setMaxKlients( maxC ) )
-                            klient->sende( "\1", 1 );
-                        else
-                        {
-                            Text* err = new Text();
-                            err->append( is->getLetzterFehler() );
-                            errorZuKlient( err->getText() );
-                            err->release();
-                        }
-                    }
-                    else
-                        errorZuKlient( "Du bist nicht berechtigt die maximale Anzahl der Clients zu verändern." );
-                }
-                break;
-            case 0xC: // klient absturtz
-                if( 1 )
-                {
-                    klient->sende( "\1", 1 );
-                    int klientId = 0;
-                    klient->getNachricht( (char*)&klientId, 4 );
-                    if( klientId && is->absturzKlient( klientId ) )
-                        klient->sende( "\1", 1 );
-                    else
-                        klient->sende( "\0", 1 );
-                }
-                break;
-            default:
-                errorZuKlient( "Unbekannte Nachricht!" );
-                break;
-            }
-            if( br )
-                break;
-            is->addEmpfangen( klient->getDownloadBytes( 1 ) );
-            is->addGesendet( klient->getUploadBytes( 1 ) );
-        }
-    }
-    is->addEmpfangen( klient->getDownloadBytes( 1 ) );
-    is->addGesendet( klient->getUploadBytes( 1 ) );
-    delete this;
+	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 = is->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 (is->zDB()->adminHatRecht(adminId, Admin_Recht::ISStarten))
+					{
+						if (!is->serverStarten())
+						{
+							Text* err = new Text();
+							err->append(is->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 (is->zDB()->adminHatRecht(adminId, Admin_Recht::ISBeenden))
+					{
+						if (is->serverBeenden())
+							klient->sende("\1", 1);
+						else
+						{
+							Text* err = new Text();
+							err->append(is->getLetzterFehler());
+							errorZuKlient(err->getText());
+							err->release();
+						}
+					}
+					else
+						errorZuKlient("Du bist nicht berechtigt den Server zu beenden.");
+				}
+				break;
+			case 6: // Programm Schließen
+				if (!adminId)
+					errorZuKlient("Du musst dich einloggen.");
+				else
+				{
+					bool ok = 0;
+					if (is->isRunning())
+					{
+						if (is->zDB()->adminHatRecht(adminId, Admin_Recht::ISBeenden))
+						{
+							if (is->serverBeenden())
+								ok = 1;
+							else
+							{
+								Text* err = new Text();
+								err->append(is->getLetzterFehler());
+								errorZuKlient(err->getText());
+								err->release();
+							}
+						}
+						else
+							errorZuKlient("Du bist nicht berechtigt den Server zu beenden.");
+					}
+					else
+						ok = 1;
+					if (ok && is->hatClients())
+					{
+						errorZuKlient("Es sind noch Klients Online. Bitte versuche es später erneut.");
+						break;
+					}
+					if (ok)
+					{
+						klient->sende("\1", 1);
+						std::cout << "IS: Der Server wird von Benutzer " << adminId << " heruntergefahren.\n";
+						is->close();
+						br = 1;
+					}
+				}
+				break;
+			case 7: // Progtamm abstürzen
+				if (!adminId)
+					errorZuKlient("Du musst dich einloggen.");
+				else
+				{
+					bool ok = 0;
+					if (is->isRunning())
+					{
+						if (is->zDB()->adminHatRecht(adminId, Admin_Recht::ISBeenden))
+						{
+							is->serverBeenden();
+							ok = 1;
+						}
+						else
+							errorZuKlient("Du bist nicht berechtigt den Server zu beenden.");
+					}
+					else
+						ok = 1;
+					if (ok)
+					{
+						klient->sende("\1", 1);
+						std::cout << "IS: Der Server wurde von Benutzer " << adminId << " terminiert.\n";
+						is->close();
+						br = 1;
+					}
+				}
+				break;
+			case 8: // Status Frage
+				if (1)
+				{
+					char status = 0;
+					if (is->isRunning())
+					{
+						status = 1;
+						if (is->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 (is->zDB()->adminHatRecht(adminId, Admin_Recht::ISPausieren))
+					{
+						bool ok = 0;
+						if (pause)
+							ok = is->serverPause();
+						else
+							ok = is->serverFortsetzen();
+						if (ok)
+							klient->sende("\1", 1);
+						else
+						{
+							Text* err = new Text();
+							err->append(is->getLetzterFehler());
+							errorZuKlient(err->getText());
+							err->release();
+						}
+					}
+					else
+					{
+						if (pause)
+							errorZuKlient("Du bist nicht berechtigt den Server zu pausieren.");
+						else
+							errorZuKlient("Du bist nicht berechtigt den Server fortzusetzen.");
+					}
+				}
+				break;
+			case 0xA: // maximale Anzahl der Clients setzen
+				if (!adminId)
+					errorZuKlient("Du musst dich einloggen.");
+				else
+				{
+					klient->sende("\1", 1);
+					int maxC = 0;
+					klient->getNachricht((char*)&maxC, 4);
+					if (is->zDB()->adminHatRecht(adminId, Admin_Recht::ISMCChange))
+					{
+						if (is->setMaxKlients(maxC))
+							klient->sende("\1", 1);
+						else
+						{
+							Text* err = new Text();
+							err->append(is->getLetzterFehler());
+							errorZuKlient(err->getText());
+							err->release();
+						}
+					}
+					else
+						errorZuKlient("Du bist nicht berechtigt die maximale Anzahl der Clients zu verändern.");
+				}
+				break;
+			case 0xC: // klient absturtz
+				if (1)
+				{
+					klient->sende("\1", 1);
+					int klientId = 0;
+					klient->getNachricht((char*)&klientId, 4);
+					if (klientId && is->absturzKlient(klientId))
+						klient->sende("\1", 1);
+					else
+						klient->sende("\0", 1);
+				}
+				break;
+			default:
+				errorZuKlient("Unbekannte Nachricht!");
+				break;
+			}
+			if (br)
+				break;
+			is->addEmpfangen(klient->getDownloadBytes(1));
+			is->addGesendet(klient->getUploadBytes(1));
+		}
+	}
+	is->addEmpfangen(klient->getDownloadBytes(1));
+	is->addGesendet(klient->getUploadBytes(1));
+	delete this;
 }
 
-void ISAKlient::errorZuKlient( const char* nachricht ) const // sendet eine Fehlernachricht zum Klient
+void ISAKlient::errorZuKlient(const char* nachricht) const // sendet eine Fehlernachricht zum Klient
 {
-    klient->sende( "\3", 1 );
-    char len = (char)textLength( nachricht );
-    klient->sende( &len, 1 );
-    klient->sende( nachricht, len );
+	klient->sende("\3", 1);
+	char len = (char)textLength(nachricht);
+	klient->sende(&len, 1);
+	klient->sende(nachricht, len);
 }
 
 
 // Inhalt der ISKlient aus InformationServer.h
 // Konstruktor 
-ISKlient::ISKlient( SKlient* klient, InformationServer* is )
-    : Thread()
+ISKlient::ISKlient(SKlient* klient, InformationServer* is)
+	: Thread()
 {
-    this->klient = klient;
-    unsigned char key[ 20 ] = { 231, 246, 125, 32, 88, 172, 229, 223, 246, 138, 74, 64, 142, 245, 217, 218, 162, 62, 103, 50 };
-    klient->setSendeKey( (char*)key, 20 );
-    klient->setEmpfangKey( (char*)key, 20 );
-    klientNummer = 0;
-    this->is = is;
+	this->klient = klient;
+	unsigned char key[20] = { 231, 246, 125, 32, 88, 172, 229, 223, 246, 138, 74, 64, 142, 245, 217, 218, 162, 62, 103, 50 };
+	klient->setSendeKey((char*)key, 20);
+	klient->setEmpfangKey((char*)key, 20);
+	klientNummer = 0;
+	this->is = is;
 }
 
 // Destruktor 
 ISKlient::~ISKlient()
 {
-    klient->release();
-    is->release();
+	klient->release();
+	is->release();
 }
 
 // nicht constant
 void ISKlient::absturz()
 {
-    ende();
-    klient->trenne();
-    is->zDB()->unregisterKlient( klientNummer, is->getId() );
+	ende();
+	klient->trenne();
+	is->zDB()->unregisterKlient(klientNummer, is->getId());
 }
 
 void ISKlient::thread()
 {
-    while( 1 )
-    {
-        char c = 0;
-        if( !klient->getNachrichtEncrypted( &c, 1 ) )
-            break;
-        else
-        {
-            bool br = 0;
-            switch( c )
-            {
-            case 1: // Klient identifikation
-                klient->getNachrichtEncrypted( (char*)&klientNummer, 4 );
-                if( !is->zDB()->proveKlient( klientNummer, is->getId() ) )
-                {
-                    klientNummer = 0;
-                    errorZuKlient( "Du bist nicht für diesen Server eingetragen" );
-                }
-                else
-                {
-                    Text* key = is->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();
-                    }
-                }
-                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 && is->absturzKlient( klientId ) )
-                                klient->sendeEncrypted( "\1", 1 );
-                            else
-                                klient->sendeEncrypted( "\0", 1 );
-                        }
-                        break;
-                    default:
-                        errorZuKlient( "Befehl nicht bekannt!" );
-                        break;
-                    }
-                }
-                break;
-            case 3: // Verbindungsende
-                br = 1;
-                klient->sendeEncrypted( "\1", 1 );
-                break;
-            case 4: // unregister Klient
-                if( !klientNummer )
-                {
-                    errorZuKlient( "Du bist nicht Identifiziert." );
-                    break;
-                }
-                is->zDB()->unregisterKlient( klientNummer, is->getId() );
-                klient->sendeEncrypted( "\1", 1 );
-                break;
-            case 5: // frage nach Informations Text
-                if( 1 )
-                {
-                    if( !klientNummer )
-                    {
-                        errorZuKlient( "Du bist nicht Identifiziert." );
-                        break;
-                    }
-                    klient->sendeEncrypted( "\1", 1 );
-                    char typ = 0;
-                    Text* info = is->zDB()->getInformationsText( &typ );
-                    unsigned short len = info ? (unsigned short)info->getLength() : (unsigned short)0;
-                    klient->sendeEncrypted( (char*)&len, 2 );
-                    if( len > 0 )
-                        klient->sendeEncrypted( info->getText(), len );
-                    klient->sendeEncrypted( &typ, 1 );
-                    if( info )
-                        info->release();
-                }
-                break;
-            case 6: // frage, ob Spiel erlaubt ist
-                if( 1 )
-                {
-                    if( !klientNummer )
-                    {
-                        errorZuKlient( "Du bist nicht Identifiziert." );
-                        break;
-                    }
-                    klient->sendeEncrypted( "\1", 1 );
-                    int spielId = 0;
-                    klient->getNachrichtEncrypted( (char*)&spielId, 4 );
-                    if( is->zDB()->istSpielErlaubt( spielId ) )
-                        klient->sendeEncrypted( "\1", 1 );
-                    else
-                        klient->sendeEncrypted( "\0", 1 );
-                }
-                break;
-            case 7: // frage, ob Karte erlaubt ist
-                if( 1 )
-                {
-                    if( !klientNummer )
-                    {
-                        errorZuKlient( "Du bist nicht Identifiziert." );
-                        break;
-                    }
-                    klient->sendeEncrypted( "\1", 1 );
-                    int karteId = 0;
-                    klient->getNachrichtEncrypted( (char*)&karteId, 4 );
-                    if( is->zDB()->istKarteErlaubt( karteId ) )
-                        klient->sendeEncrypted( "\1", 1 );
-                    else
-                        klient->sendeEncrypted( "\0", 1 );
-                }
-                break;
-            case 8: // Frage nach Spiel Id
-                if( 1 )
-                {
-                    if( !klientNummer )
-                    {
-                        errorZuKlient( "Du bist nicht Identifiziert." );
-                        break;
-                    }
-                    klient->sendeEncrypted( "\1", 1 );
-                    unsigned char len = 0;
-                    klient->getNachrichtEncrypted( (char*)&len, 1 );
-                    char* name = new char[ len + 1 ];
-                    name[ (int)len ] = 0;
-                    klient->getNachrichtEncrypted( name, len );
-                    int id = is->zDB()->getSpielId( name );
-                    klient->sendeEncrypted( (char*)&id, 4 );
-                    delete[] name;
-                }
-                break;
-            case 9: // Frage nach Karte Id
-                if( 1 )
-                {
-                    if( !klientNummer )
-                    {
-                        errorZuKlient( "Du bist nicht Identifiziert." );
-                        break;
-                    }
-                    klient->sendeEncrypted( "\1", 1 );
-                    unsigned char len = 0;
-                    klient->getNachrichtEncrypted( (char*)&len, 1 );
-                    char* name = new char[ len + 1 ];
-                    name[ (int)len ] = 0;
-                    klient->getNachrichtEncrypted( name, len );
-                    int id = is->zDB()->getKarteId( name );
-                    klient->sendeEncrypted( (char*)&id, 4 );
-                    delete[] name;
-                }
-                break;
-            case 0xA: // Frage nach Account rufName
-                if( 1 )
-                {
-                    if( !klientNummer )
-                    {
-                        errorZuKlient( "Du bist nicht Identifiziert." );
-                        break;
-                    }
-                    klient->sendeEncrypted( "\1", 1 );
-                    int accountId = 0;
-                    klient->getNachrichtEncrypted( (char*)&accountId, 4 );
-                    Text* rName = is->zDB()->getAccountRufName( accountId );
-                    if( rName )
-                    {
-                        char len = (char)rName->getLength();
-                        klient->sendeEncrypted( &len, 1 );
-                        klient->sendeEncrypted( rName->getText(), len );
-                        rName->release();
-                    }
-                    else
-                        klient->sendeEncrypted( "\0", 1 );
-                }
-                break;
-            case 0xB: // Frage nach Spiel Statistik
-                if( 1 )
-                {
-                    if( !klientNummer )
-                    {
-                        errorZuKlient( "Du bist nicht Identifiziert." );
-                        break;
-                    }
-                    klient->sendeEncrypted( "\1", 1 );
-                    int accountId = 0;
-                    int spielId = 0;
-                    klient->getNachrichtEncrypted( (char*)&accountId, 4 );
-                    klient->getNachrichtEncrypted( (char*)&spielId, 4 );
-                    Array< int >* values = is->zDB()->getAccountSpielStatistik( accountId, spielId );
-                    for( int i = 0; i < 10; i++ )
-                    {
-                        int tmp = values ? values->get( i ) : 0;
-                        klient->sendeEncrypted( (char*)&tmp, 4 );
-                    }
-                    if( values )
-                        values->release();
-                }
-                break;
-            case 0xC: // Frage nach Spieler Liste
-                if( !klientNummer )
-                {
-                    errorZuKlient( "Du bist nicht Identifiziert." );
-                    break;
-                }
-                else
-                {
-                    klient->sendeEncrypted( "\1", 1 );
-                    unsigned char len = 0;
-                    klient->getNachrichtEncrypted( (char*)&len, 1 );
-                    char* suche = new char[ len + 1 ];
-                    suche[ (int)len ] = 0;
-                    klient->getNachrichtEncrypted( suche, len );
-                    int seite = 0;
-                    klient->getNachrichtEncrypted( (char*)&seite, 4 );
-                    char sortSpalte = 0;
-                    char backwords = 0;
-                    klient->getNachrichtEncrypted( &sortSpalte, 1 );
-                    klient->getNachrichtEncrypted( &backwords, 1 );
-                    int maxSeite = 0;
-                    Result list = is->zDB()->getSpielerListe( suche, &seite, &maxSeite, sortSpalte, backwords != 0 );
-                    delete[] suche;
-                    klient->sendeEncrypted( (char*)&seite, 4 );
-                    klient->sendeEncrypted( (char*)&maxSeite, 4 );
-                    klient->sendeEncrypted( (char*)&list.zeilenAnzahl, 4 );
-                    for( int i = 0; i < list.zeilenAnzahl; i++ )
-                    {
-                        int accId = list.values[ i * 6 ];
-                        klient->sendeEncrypted( (char*)&accId, 4 );
-                        len = (char)list.values[ i * 6 + 1 ].getLength();
-                        klient->sendeEncrypted( (char*)&len, 1 );
-                        klient->sendeEncrypted( list.values[ i * 6 + 1 ], len );
-                        len = (char)list.values[ i * 6 + 2 ].getLength();
-                        klient->sendeEncrypted( (char*)&len, 1 );
-                        klient->sendeEncrypted( list.values[ i * 6 + 2 ], len );
-                        len = (char)list.values[ i * 6 + 3 ].getLength();
-                        klient->sendeEncrypted( (char*)&len, 1 );
-                        klient->sendeEncrypted( list.values[ i * 6 + 3 ], len );
-                        len = (char)list.values[ i * 6 + 4 ].getLength();
-                        klient->sendeEncrypted( (char*)&len, 1 );
-                        klient->sendeEncrypted( list.values[ i * 6 + 4 ], len );
-                        len = (char)list.values[ i * 6 + 5 ].getLength();
-                        klient->sendeEncrypted( (char*)&len, 1 );
-                        klient->sendeEncrypted( list.values[ i * 6 + 5 ], len );
-                    }
-                    list.destroy();
-                }
-                break;
-            case 0xD: // Frage nach Gruppe Karte Id
-                if( 1 )
-                {
-                    if( !klientNummer )
-                    {
-                        errorZuKlient( "Du bist nicht Identifiziert." );
-                        break;
-                    }
-                    klient->sendeEncrypted( "\1", 1 );
-                    int gruppeId = 0;
-                    klient->getNachrichtEncrypted( (char*)&gruppeId, 4 );
-                    int karteId = is->zDB()->getGruppenKarteId( gruppeId );
-                    klient->sendeEncrypted( (char*)&karteId, 4 );
-                }
-                break;
-            case 0xE: // Frage nach Karten Name
-                if( 1 )
-                {
-                    if( !klientNummer )
-                    {
-                        errorZuKlient( "Du bist nicht Identifiziert." );
-                        break;
-                    }
-                    klient->sendeEncrypted( "\1", 1 );
-                    int karteId = 0;
-                    klient->getNachrichtEncrypted( (char*)&karteId, 4 );
-                    Text* name = is->zDB()->getKarteName( karteId );
-                    if( !name )
-                    {
-                        klient->sendeEncrypted( "\0", 1 );
-                        break;
-                    }
-                    char len = (char)name->getLength();
-                    klient->sendeEncrypted( &len, 1 );
-                    klient->sendeEncrypted( name->getText(), len );
-                    name->release();
-                }
-                break;
-            case 0xF: // Frage nach Spiel Name
-                if( 1 )
-                {
-                    if( !klientNummer )
-                    {
-                        errorZuKlient( "Du bist nicht Identifiziert." );
-                        break;
-                    }
-                    klient->sendeEncrypted( "\1", 1 );
-                    int spielId = 0;
-                    klient->getNachrichtEncrypted( (char*)&spielId, 4 );
-                    Text* name = is->zDB()->getSpielName( spielId );
-                    if( !name )
-                    {
-                        klient->sendeEncrypted( "\0", 1 );
-                        break;
-                    }
-                    char len = (char)name->getLength();
-                    klient->sendeEncrypted( &len, 1 );
-                    klient->sendeEncrypted( name->getText(), len );
-                    name->release();
-                }
-                break;
-            case 0x10: // Frage nach Chatroom Name
-                if( 1 )
-                {
-                    if( !klientNummer )
-                    {
-                        errorZuKlient( "Du bist nicht Identifiziert." );
-                        break;
-                    }
-                    klient->sendeEncrypted( "\1", 1 );
-                    int chatroomId = 0;
-                    klient->getNachrichtEncrypted( (char*)&chatroomId, 4 );
-                    Text* name = is->zDB()->getChatroomName( chatroomId );
-                    if( !name )
-                    {
-                        klient->sendeEncrypted( "\0", 1 );
-                        break;
-                    }
-                    char len = (char)name->getLength();
-                    klient->sendeEncrypted( &len, 1 );
-                    klient->sendeEncrypted( name->getText(), len );
-                    name->release();
-                }
-                break;
-            case 0x11: // Frage nach Spiel Id
-                if( 1 )
-                {
-                    if( !klientNummer )
-                    {
-                        errorZuKlient( "Du bist nicht Identifiziert." );
-                        break;
-                    }
-                    klient->sendeEncrypted( "\1", 1 );
-                    int karteId = 0;
-                    klient->getNachrichtEncrypted( (char*)&karteId, 4 );
-                    int spielId = is->zDB()->getSpielId( karteId );
-                    klient->sendeEncrypted( (char*)&spielId, 4 );
-                }
-                break;
-            case 0x12: // Frage nach Spieler Id
-                if( 1 )
-                {
-                    if( !klientNummer )
-                    {
-                        errorZuKlient( "Du bist nicht Identifiziert." );
-                        break;
-                    }
-                    klient->sendeEncrypted( "\1", 1 );
-                    unsigned char len = 0;
-                    klient->getNachrichtEncrypted( (char*)&len, 1 );
-                    if( len )
-                    {
-                        char* name = new char[ len + 1 ];
-                        name[ (int)len ] = 0;
-                        klient->getNachrichtEncrypted( name, len );
-                        int id = is->zDB()->getAccountId( name );
-                        klient->sendeEncrypted( (char*)&id, 4 );
-                        delete[]name;
-                    }
-                }
-                break;
-            case 0x13: // Frage nach Chatroom Id
-                if( 1 )
-                {
-                    if( !klientNummer )
-                    {
-                        errorZuKlient( "Du bist nicht Identifiziert." );
-                        break;
-                    }
-                    klient->sendeEncrypted( "\1", 1 );
-                    unsigned char len = 0;
-                    klient->getNachrichtEncrypted( (char*)&len, 1 );
-                    if( len )
-                    {
-                        char* name = new char[ len + 1 ];
-                        name[ (int)len ] = 0;
-                        klient->getNachrichtEncrypted( name, len );
-                        int id = is->zDB()->getChatroomId( name );
-                        klient->sendeEncrypted( (char*)&id, 4 );
-                        delete[]name;
-                    }
-                }
-                break;
-            case 0x14: // Frage nach Spiel Punkten
-                if( 1 )
-                {
-                    if( !klientNummer )
-                    {
-                        errorZuKlient( "Du bist nicht Identifiziert." );
-                        break;
-                    }
-                    klient->sendeEncrypted( "\1", 1 );
-                    int spielId = 0;
-                    int accountId = 0;
-                    klient->getNachrichtEncrypted( (char*)&spielId, 4 );
-                    klient->getNachrichtEncrypted( (char*)&accountId, 4 );
-                    int ret = is->zDB()->getSpielerPunkte( spielId, accountId );
-                    klient->sendeEncrypted( (char*)&ret, 4 );
-                }
-                break;
-            case 0x15: // Frage nach Gruppe Administrator
-                if( 1 )
-                {
-                    if( !klientNummer )
-                    {
-                        errorZuKlient( "Du bist nicht Identifiziert." );
-                        break;
-                    }
-                    klient->sendeEncrypted( "\1", 1 );
-                    int gruppeId = 0;
-                    klient->getNachrichtEncrypted( (char*)&gruppeId, 4 );
-                    int ret = is->zDB()->getGruppeAdminId( gruppeId );
-                    klient->sendeEncrypted( (char*)&ret, 4 );
-                }
-                break;
-            case 0x16: // Frage nach Spiel Liste
-                if( klientNummer )
-                {
-                    klient->sendeEncrypted( "\1", 1 );
-                    Array< int >* list = is->zDB()->getAccountSpielArtListe( klientNummer );
-                    if( !list )
-                    {
-                        klient->sendeEncrypted( "\0\0\0\0", 4 );
-                        break;
-                    }
-                    int anz = list->getEintragAnzahl();
-                    klient->sendeEncrypted( (char*)&anz, 4 );
-                    for( int i = 0; i < anz; i++ )
-                    {
-                        int id = list->get( i );
-                        klient->sendeEncrypted( (char*)&id, 4 );
-                    }
-                }
-                else
-                    errorZuKlient( "Du bist nicht Identifiziert." );
-                break;
-            case 0x17: // Frage nach neuster Spiel Version
-                if( klientNummer )
-                {
-                    klient->sendeEncrypted( "\1", 1 );
-                    int id = 0;
-                    klient->getNachrichtEncrypted( (char*)&id, 4 );
-                    int v = is->zDB()->getNeusteSpielVersion( id );
-                    klient->sendeEncrypted( (char*)&v, 4 );
-                }
-                else
-                    errorZuKlient( "Du bist nicht Identifiziert." );
-                break;
-            case 0x18: // Frage nach Kupfer
-                if( klientNummer )
-                {
-                    klient->sendeEncrypted( "\1", 1 );
-                    int k = is->zDB()->getKupfer( klientNummer );
-                    klient->sendeEncrypted( (char*)&k, 4 );
-                }
-                else
-                    errorZuKlient( "Du bist nicht Identifiziert." );
-                break;
-            case 0x19: // Frage nach Dateigruppen Id von Spiel
-                if( klientNummer )
-                {
-                    klient->sendeEncrypted( "\1", 1 );
-                    int spielId = 0;
-                    klient->getNachrichtEncrypted( (char*)&spielId, 4 );
-                    int dgId = is->zDB()->getDateiGruppeVonSpiel( spielId );
-                    klient->sendeEncrypted( (char*)&dgId, 4 );
-                }
-                else
-                    errorZuKlient( "Du bist nicht Identifiziert." );
-                break;
-            case 0x1A: // Frage nach Dateigruppen Pfad
-                if( klientNummer )
-                {
-                    klient->sendeEncrypted( "\1", 1 );
-                    int dgId = 0;
-                    klient->getNachrichtEncrypted( (char*)&dgId, 4 );
-                    Text* pf = is->zDB()->getDateiGruppePfad( dgId );
-                    if( !pf )
-                        errorZuKlient( "Die Dateigruppe wurde nicht gefunden." );
-                    else
-                    {
-                        klient->sendeEncrypted( "\1", 1 );
-                        char len = (char)pf->getLength();
-                        klient->sendeEncrypted( &len, 1 );
-                        if( len )
-                            klient->sendeEncrypted( pf->getText(), len );
-                        pf->release();
-                    }
-                }
-                else
-                    errorZuKlient( "Du bist nicht Identifiziert." );
-                break;
-            case 0x1B: // Frage nach karte Liste
-                if( klientNummer )
-                {
-                    klient->sendeEncrypted( "\1", 1 );
-                    int spielId = 0;
-                    klient->getNachrichtEncrypted( (char*)&spielId, 4 );
-                    Array< int >* list = is->zDB()->getAccountKarteListe( klientNummer, spielId );
-                    if( !list )
-                    {
-                        klient->sendeEncrypted( "\0\0\0\0", 4 );
-                        break;
-                    }
-                    int anz = list->getEintragAnzahl();
-                    klient->sendeEncrypted( (char*)&anz, 4 );
-                    for( int i = 0; i < anz; i++ )
-                    {
-                        int id = list->get( i );
-                        klient->sendeEncrypted( (char*)&id, 4 );
-                    }
-                }
-                else
-                    errorZuKlient( "Du bist nicht Identifiziert." );
-                break;
-            case 0x1E: // Frage nach Gruppe Spieler Hinzufügen
-                if( klientNummer )
-                {
-                    klient->sendeEncrypted( "\1", 1 );
-                    int gruppeId = 0;
-                    klient->getNachrichtEncrypted( (char*)&gruppeId, 4 );
-                    char gSH = (char)is->zDB()->getGruppeSpielerAdd( gruppeId );
-                    klient->sendeEncrypted( &gSH, 1 );
-                }
-                else
-                    errorZuKlient( "Du bist nicht Identifiziert." );
-                break;
-            case 0x1F: // Frage nach Spieler Aktivität
-                if( klientNummer )
-                {
-                    klient->sendeEncrypted( "\1", 1 );
-                    int acc = 0;
-                    klient->getNachrichtEncrypted( (char*)&acc, 4 );
-                    RCArray< Text >* datum = new RCArray< Text >();
-                    Array< double >* stOnline = new Array< double >();
-                    Array< double >* stSpiel = new Array< double >();
-                    Array< int >* anzSpiele = new Array< int >();
-                    Array< int >* anzGewonnen = new Array< int >();
-                    if( is->zDB()->getSpielerAktivity( acc, datum, stOnline, stSpiel, anzSpiele, anzGewonnen ) )
-                    {
-                        klient->sendeEncrypted( "\1", 1 );
-                        int anz = datum->getEintragAnzahl();
-                        for( int i = 0; i < anz; i++ )
-                        {
-                            if( datum->z( i ) )
-                            {
-                                char len = (char)datum->get( i )->getLength();
-                                if( len )
-                                {
-                                    klient->sendeEncrypted( &len, 1 );
-                                    klient->sendeEncrypted( datum->z( i )->getText(), len );
-                                    double sto = stOnline->hat( i ) ? stOnline->get( i ) : 0;
-                                    klient->sendeEncrypted( (char*)&sto, 8 );
-                                    double sts = stSpiel->hat( i ) ? stSpiel->get( i ) : 0;
-                                    klient->sendeEncrypted( (char*)&sts, 8 );
-                                    int anzs = anzSpiele->hat( i ) ? anzSpiele->get( i ) : 0;
-                                    klient->sendeEncrypted( (char*)&anzs, 4 );
-                                    int anzg = anzGewonnen->hat( i ) ? anzGewonnen->get( i ) : 0;
-                                    klient->sendeEncrypted( (char*)&anzg, 4 );
-                                }
-                            }
-                        }
-                        klient->sendeEncrypted( "\0", 1 );
-                    }
-                    else
-                        errorZuKlient( "Keine Daten gefunden." );
-                    datum->release();
-                    stOnline->release();
-                    stSpiel->release();
-                    anzSpiele->release();
-                    anzGewonnen->release();
-                }
-                else
-                    errorZuKlient( "Du bist nicht Identifiziert." );
-                break;
-            case 0x20: // Frage nach Anzahl der gespielten Spiele von Karte
-                if( klientNummer )
-                {
-                    klient->sendeEncrypted( "\1", 1 );
-                    int acc = 0;
-                    int karte = 0;
-                    klient->getNachrichtEncrypted( (char*)&acc, 4 );
-                    klient->getNachrichtEncrypted( (char*)&karte, 4 );
-                    int anz = is->zDB()->getAccountKarteSpiele( acc, karte );
-                    klient->sendeEncrypted( (char*)&anz, 4 );
-                }
-                else
-                    errorZuKlient( "Du bist nicht Identifiziert." );
-                break;
-            case 0x21: // Frage nach Anzahl gewonnener Spiele von Karte
-                if( klientNummer )
-                {
-                    klient->sendeEncrypted( "\1", 1 );
-                    int acc = 0;
-                    int karte = 0;
-                    klient->getNachrichtEncrypted( (char*)&acc, 4 );
-                    klient->getNachrichtEncrypted( (char*)&karte, 4 );
-                    int anz = is->zDB()->getAccountKarteSpieleGewonnen( acc, karte );
-                    klient->sendeEncrypted( (char*)&anz, 4 );
-                }
-                else
-                    errorZuKlient( "Du bist nicht Identifiziert." );
-                break;
-            case 0x22: // Frage nach Besitz Status von Karte
-                if( klientNummer )
-                {
-                    klient->sendeEncrypted( "\1", 1 );
-                    int acc = 0;
-                    int karte = 0;
-                    klient->getNachrichtEncrypted( (char*)&acc, 4 );
-                    klient->getNachrichtEncrypted( (char*)&karte, 4 );
-                    char status = (char)is->zDB()->hatAccountKarte( acc, karte );
-                    klient->sendeEncrypted( &status, 1 );
-                }
-                else
-                    errorZuKlient( "Du bist nicht Identifiziert." );
-                break;
-            case 0x23: // Frage nach Besitz Status von Spiel
-                if( klientNummer )
-                {
-                    klient->sendeEncrypted( "\1", 1 );
-                    int acc = 0;
-                    int spiel = 0;
-                    klient->getNachrichtEncrypted( (char*)&acc, 4 );
-                    klient->getNachrichtEncrypted( (char*)&spiel, 4 );
-                    char status = (char)is->zDB()->hatAccountSpiel( acc, spiel );
-                    klient->sendeEncrypted( &status, 1 );
-                }
-                else
-                    errorZuKlient( "Du bist nicht Identifiziert." );
-                break;
-            case 0x24: // Frage nach Liste mit gespielten Karten
-                if( klientNummer )
-                {
-                    klient->sendeEncrypted( "\1", 1 );
-                    int acc = 0;
-                    int spiel = 0;
-                    klient->getNachrichtEncrypted( (char*)&acc, 4 );
-                    klient->getNachrichtEncrypted( (char*)&spiel, 4 );
-                    Array< int >* res = is->zDB()->getAccountKarteGespieltListe( acc, spiel );
-                    if( res )
-                    {
-                        int anz = res->getEintragAnzahl();
-                        klient->sendeEncrypted( (char*)&anz, 4 );
-                        for( int i = 0; i < anz; i++ )
-                        {
-                            int val = res->get( i );
-                            klient->sendeEncrypted( (char*)&val, 4 );
-                        }
-                        res->release();
-                    }
-                    else
-                        klient->sendeEncrypted( "\0\0\0\0", 4 );
-                }
-                else
-                    errorZuKlient( "Du bist nicht Identifiziert." );
-                break;
-            case 0x25: // Frage nach Liste mit gespielten Spielen
-                if( klientNummer )
-                {
-                    klient->sendeEncrypted( "\1", 1 );
-                    int acc = 0;
-                    klient->getNachrichtEncrypted( (char*)&acc, 4 );
-                    Array< int >* res = is->zDB()->getAccountSpielGespieltListe( acc );
-                    if( res )
-                    {
-                        int anz = res->getEintragAnzahl();
-                        klient->sendeEncrypted( (char*)&anz, 4 );
-                        for( int i = 0; i < anz; i++ )
-                        {
-                            int val = res->get( i );
-                            klient->sendeEncrypted( (char*)&val, 4 );
-                        }
-                        res->release();
-                    }
-                    else
-                        klient->sendeEncrypted( "\0\0\0\0", 4 );
-                }
-                else
-                    errorZuKlient( "Du bist nicht Identifiziert." );
-                break;
-            case 0x26: // Frage nach Liste mit spiel Partnern
-                if( klientNummer )
-                {
-                    klient->sendeEncrypted( "\1", 1 );
-                    int acc = 0;
-                    klient->getNachrichtEncrypted( (char*)&acc, 4 );
-                    Result res = is->zDB()->getSpielPartnerListe( acc );
-                    klient->sendeEncrypted( (char*)&res.zeilenAnzahl, 4 );
-                    for( int i = 0; i < res.zeilenAnzahl; i++ )
-                    {
-                        int spieler = res.values[ i * 3 ];
-                        int anzahl = res.values[ i * 3 + 1 ];
-                        int karte = res.values[ i * 3 + 2 ];
-                        klient->sendeEncrypted( (char*)&spieler, 4 );
-                        klient->sendeEncrypted( (char*)&karte, 4 );
-                        klient->sendeEncrypted( (char*)&anzahl, 4 );
-                    }
-                    res.destroy();
-                }
-                else
-                    errorZuKlient( "Du bist nicht Identifiziert." );
-                break;
-            case 0x27: // Frage nach Liste mit spiel Statistiken
-                if( klientNummer )
-                {
-                    klient->sendeEncrypted( "\1", 1 );
-                    int acc = 0;
-                    klient->getNachrichtEncrypted( (char*)&acc, 4 );
-                    int seite = 0;
-                    klient->getNachrichtEncrypted( (char*)&seite, 4 );
-                    char sortSpalte = 0;
-                    char backwords = 0;
-                    klient->getNachrichtEncrypted( &sortSpalte, 1 );
-                    klient->getNachrichtEncrypted( &backwords, 1 );
-                    int maxSeite = 0;
-                    Result list = is->zDB()->getSpielStatistikListe( acc, &seite, &maxSeite, sortSpalte, backwords != 0 );
-                    klient->sendeEncrypted( (char*)&seite, 4 );
-                    klient->sendeEncrypted( (char*)&maxSeite, 4 );
-                    klient->sendeEncrypted( (char*)&list.zeilenAnzahl, 4 );
-                    klient->sendeEncrypted( (char*)&list.feldAnzahl, 4 );
-                    for( int i = 0; i < list.zeilenAnzahl; i++ )
-                    {
-                        for( int j = 0; j < list.feldAnzahl; j++ )
-                        {
-                            if( j != 1 )
-                            {
-                                int val = list.values[ j + i * list.feldAnzahl ];
-                                klient->sendeEncrypted( (char*)&val, 4 );
-                            }
-                            else
-                            {
-                                char len = (char)(list.values[ j + i * list.feldAnzahl ].getLength());
-                                klient->sendeEncrypted( &len, 1 );
-                                if( len )
-                                    klient->sendeEncrypted( list.values[ j + i * list.feldAnzahl ], len );
-                            }
-                        }
-                    }
-                    list.destroy();
-                }
-                else
-                    errorZuKlient( "Du bist nicht Identifiziert." );
-                break;
-            case 0x28: // Spiel Historie Liste
-                if( klientNummer )
-                {
-                    klient->sendeEncrypted( "\1", 1 );
-                    int acc = 0;
-                    klient->getNachrichtEncrypted( (char*)&acc, 4 );
-                    AHDaten* daten = is->zDB()->getSpielHistorie( acc, is );
-                    if( daten )
-                    {
-                        char anz = (char)daten->spiele->getEintragAnzahl();
-                        klient->sendeEncrypted( &anz, 1 );
-                        for( char i = 0; i < anz; i++ )
-                        {
-                            AHSpielDaten* spiel = daten->spiele->z( i );
-                            klient->sendeEncrypted( (char*)&spiel->id, 4 );
-                            klient->sendeEncrypted( (char*)&spiel->karteId, 4 );
-                            char len = (char)spiel->spiel->getLength();
-                            klient->sendeEncrypted( &len, 1 );
-                            if( len )
-                                klient->sendeEncrypted( *spiel->spiel, len );
-                            len = (char)spiel->karte->getLength();
-                            klient->sendeEncrypted( &len, 1 );
-                            if( len )
-                                klient->sendeEncrypted( *spiel->karte, len );
-                            len = (char)spiel->datum->getLength();
-                            klient->sendeEncrypted( &len, 1 );
-                            if( len )
-                                klient->sendeEncrypted( *spiel->datum, len );
-                            len = (char)spiel->status->getLength();
-                            klient->sendeEncrypted( &len, 1 );
-                            if( len )
-                                klient->sendeEncrypted( *spiel->status, len );
-                            len = (char)spiel->dauer->getLength();
-                            klient->sendeEncrypted( &len, 1 );
-                            if( len )
-                                klient->sendeEncrypted( *spiel->dauer, len );
-                            len = (char)spiel->spielStatus->getLength();
-                            klient->sendeEncrypted( &len, 1 );
-                            if( len )
-                                klient->sendeEncrypted( *spiel->spielStatus, len );
-                            len = (char)spiel->gewinner->getLength();
-                            klient->sendeEncrypted( &len, 1 );
-                            if( len )
-                                klient->sendeEncrypted( *spiel->gewinner, len );
-                            klient->sendeEncrypted( (char*)&spiel->sAnzahl, 4 );
-                            char tAnz = (char)spiel->teams->getEintragAnzahl();
-                            klient->sendeEncrypted( &tAnz, 1 );
-                            for( char j = 0; j < tAnz; j++ )
-                            {
-                                AHSpielTeamDaten* team = spiel->teams->z( j );
-                                char len = (char)team->name->getLength();
-                                klient->sendeEncrypted( &len, 1 );
-                                if( len )
-                                    klient->sendeEncrypted( *team->name, len );
-                                klient->sendeEncrypted( (char*)&team->sAnzahl, 4 );
-                                len = (char)team->status->getLength();
-                                klient->sendeEncrypted( &len, 1 );
-                                if( len )
-                                    klient->sendeEncrypted( *team->status, len );
-                                klient->sendeEncrypted( (char*)&team->farbe, 4 );
-                                char sAnz = (char)team->spieler->getEintragAnzahl();
-                                klient->sendeEncrypted( &sAnz, 1 );
-                                for( char k = 0; k < sAnz; k++ )
-                                {
-                                    AHSpielSpielerDaten* spieler = team->spieler->z( k );
-                                    char len = (char)spieler->name->getLength();
-                                    klient->sendeEncrypted( &len, 1 );
-                                    if( len )
-                                        klient->sendeEncrypted( *spieler->name, len );
-                                    klient->sendeEncrypted( (char*)&spieler->punkte, 4 );
-                                    len = (char)spieler->status->getLength();
-                                    klient->sendeEncrypted( &len, 1 );
-                                    if( len )
-                                        klient->sendeEncrypted( *spieler->status, len );
-                                    klient->sendeEncrypted( (char*)&spieler->farbe, 4 );
-                                }
-                            }
-                        }
-                        daten->release();
-                    }
-                    else
-                        klient->sendeEncrypted( "\0", 1 );
-                }
-                else
-                    errorZuKlient( "Du bist nicht Identifiziert." );
-                break;
-            case 0x29: // Frage nach Historie Server
-                if( klientNummer )
-                {
-                    klient->sendeEncrypted( "\1", 1 );
-                    int spielId = 0;
-                    klient->getNachrichtEncrypted( (char*)&spielId, 4 );
-                    int port = 0;
-                    Text* ip = new Text();
-                    if( is->zDB()->getHistorieServerPortIp( klientNummer, spielId, &port, ip ) )
-                    {
-                        klient->sendeEncrypted( "\1", 1 );
-                        klient->sendeEncrypted( (char*)&port, 4 );
-                        char len = (char)ip->getLength();
-                        klient->sendeEncrypted( &len, 1 );
-                        klient->sendeEncrypted( *ip, len );
-                    }
-                    else
-                        errorZuKlient( "Die Daten für dieses Spiel sind vorrübergehend nicht verfügbar." );
-                    ip->release();
-                }
-                else
-                    errorZuKlient( "Du bist nicht Identifiziert." );
-                break;
-            case 0x2A: // Frage nach Dateigruppen Id von Pfad
-                if( klientNummer )
-                {
-                    klient->sendeEncrypted( "\1", 1 );
-                    unsigned char len = 0;
-                    klient->getNachrichtEncrypted( (char*)&len, 1 );
-                    char* pf = new char[ len + 1 ];
-                    pf[ (int)len ] = 0;
-                    klient->getNachrichtEncrypted( (char*)pf, len );
-                    int dgId = is->zDB()->getDateiGruppeVonPfad( pf );
-                    delete[] pf;
-                    klient->sendeEncrypted( (char*)&dgId, 4 );
-                }
-                else
-                    errorZuKlient( "Du bist nicht Identifiziert." );
-                break;
-            case 0x2B: // Frage nach neuster Version einer Dateigruppe
-                if( klientNummer )
-                {
-                    klient->sendeEncrypted( "\1", 1 );
-                    int dg = 0;
-                    klient->getNachrichtEncrypted( (char*)&dg, 4 );
-                    int v = is->zDB()->getNeusteDateiGruppe( dg );
-                    klient->sendeEncrypted( (char*)&v, 4 );
-                }
-                else
-                    errorZuKlient( "Du bist nicht Identifiziert." );
-                break;
-            case 0x2C: // ping
-                if( 1 )
-                {
-                    if( !klientNummer )
-                    {
-                        errorZuKlient( "Du bist nicht Identifiziert." );
-                        break;
-                    }
-                    klient->sendeEncrypted( "\1", 1 );
-                }
-                break;
-            case 0x2D: // Hat Account Recht
-                if( !klientNummer )
-                {
-                    errorZuKlient( "Du bist nicht Identifiziert." );
-                    break;
-                }
-                else
-                {
-                    klient->sendeEncrypted( "\1", 1 );
-                    int recht = 0;
-                    klient->getNachrichtEncrypted( (char*)&recht, 4 );
-                    if( is->zDB()->hatKlientRecht( klientNummer, recht ) )
-                        klient->sendeEncrypted( "\1", 1 );
-                    else
-                        klient->sendeEncrypted( "\0", 1 );
-                }
-                break;
-            case 0x2E: // Karten Liste
-                if( !klientNummer )
-                {
-                    errorZuKlient( "Du bist nicht Identifiziert." );
-                    break;
-                }
-                else
-                {
-                    klient->sendeEncrypted( "\1", 1 );
-                    unsigned char filterLen = 0;
-                    klient->getNachrichtEncrypted( (char*)&filterLen, 1 );
-                    char* filter = new char[ filterLen + 1 ];
-                    filter[ (int)filterLen ] = 0;
-                    if( filterLen )
-                        klient->getNachrichtEncrypted( filter, filterLen );
-                    char sortSpalte = 0;
-                    klient->getNachrichtEncrypted( &sortSpalte, 1 );
-                    char sortRichtung = 0;
-                    klient->getNachrichtEncrypted( &sortRichtung, 1 );
-                    Result res = is->zDB()->getKartenListe( klientNummer, filter, sortSpalte, sortRichtung );
-                    delete[] filter;
-                    klient->sendeEncrypted( (char*)&res.zeilenAnzahl, 4 );
-                    for( int i = 0; i < res.zeilenAnzahl; i++ )
-                    {
-                        int val = res.values[ i * 6 ];
-                        klient->sendeEncrypted( (char*)&val, 4 );
-                        char len = (char)res.values[ i * 6 + 1 ].getLength();
-                        klient->sendeEncrypted( &len, 1 );
-                        if( len )
-                            klient->sendeEncrypted( res.values[ i * 6 + 1 ], len );
-                        len = (char)res.values[ i * 6 + 2 ].getLength();
-                        klient->sendeEncrypted( &len, 1 );
-                        if( len )
-                            klient->sendeEncrypted( res.values[ i * 6 + 2 ], len );
-                        val = res.values[ i * 6 + 3 ];
-                        klient->sendeEncrypted( (char*)&val, 4 );
-                        val = res.values[ i * 6 + 4 ];
-                        klient->sendeEncrypted( (char*)&val, 4 );
-                        val = res.values[ i * 6 + 5 ];
-                        klient->sendeEncrypted( (char*)&val, 4 );
-                    }
-                    res.destroy();
-                }
-                break;
-            case 0x2F: // Editor Server Anfrage
-                if( !klientNummer )
-                {
-                    errorZuKlient( "Du bist nicht Identifiziert." );
-                    break;
-                }
-                else
-                {
-                    klient->sendeEncrypted( "\1", 1 );
-                    int karteId = 0;
-                    klient->getNachrichtEncrypted( (char*)&karteId, 4 );
-                    int port = 0;
-                    Text ip;
-                    if( !is->zDB()->getEditorServerPortIp( klientNummer, karteId, &port, &ip ) )
-                    {
-                        errorZuKlient( "Du kannst diese Karte momentan nicht abrufen." );
-                        break;
-                    }
-                    klient->sendeEncrypted( "\1", 1 );
-                    klient->sendeEncrypted( (char*)&port, 4 );
-                    char len = (char)ip.getLength();
-                    klient->sendeEncrypted( &len, 1 );
-                    klient->sendeEncrypted( ip, len );
-                }
-                break;
-            case 0x30: // Karten Server Anfrage
-                if( !klientNummer )
-                {
-                    errorZuKlient( "Du bist nicht Identifiziert." );
-                    break;
-                }
-                else
-                {
-                    klient->sendeEncrypted( "\1", 1 );
-                    int karteId = 0;
-                    klient->getNachrichtEncrypted( (char*)&karteId, 4 );
-                    int port = 0;
-                    Text ip;
-                    if( !is->zDB()->getKartenServerPortIp( klientNummer, karteId, &port, &ip ) )
-                    {
-                        errorZuKlient( "Diese Karte ist vorrübergehend nicht erreichbar." );
-                        break;
-                    }
-                    klient->sendeEncrypted( "\1", 1 );
-                    klient->sendeEncrypted( (char*)&port, 4 );
-                    char len = (char)ip.getLength();
-                    klient->sendeEncrypted( &len, 1 );
-                    klient->sendeEncrypted( ip, len );
-                }
-                break;
-            default:
-                errorZuKlient( "Unbekannte Nachricht!" );
-                break;
-            }
-            if( br )
-                break;
-            is->addEmpfangen( klient->getDownloadBytes( 1 ) );
-            is->addGesendet( klient->getUploadBytes( 1 ) );
-        }
-    }
-    is->addEmpfangen( klient->getDownloadBytes( 1 ) );
-    is->addGesendet( klient->getUploadBytes( 1 ) );
-    is->removeKlient( this ); // delete this
+	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 (!is->zDB()->proveKlient(klientNummer, is->getId()))
+				{
+					klientNummer = 0;
+					errorZuKlient("Du bist nicht für diesen Server eingetragen");
+				}
+				else
+				{
+					Text* key = is->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();
+					}
+				}
+				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 && is->absturzKlient(klientId))
+								klient->sendeEncrypted("\1", 1);
+							else
+								klient->sendeEncrypted("\0", 1);
+						}
+						break;
+					default:
+						errorZuKlient("Befehl nicht bekannt!");
+						break;
+					}
+				}
+				break;
+			case 3: // Verbindungsende
+				br = 1;
+				klient->sendeEncrypted("\1", 1);
+				break;
+			case 4: // unregister Klient
+				if (!klientNummer)
+				{
+					errorZuKlient("Du bist nicht Identifiziert.");
+					break;
+				}
+				is->zDB()->unregisterKlient(klientNummer, is->getId());
+				klient->sendeEncrypted("\1", 1);
+				break;
+			case 5: // frage nach Informations Text
+				if (1)
+				{
+					if (!klientNummer)
+					{
+						errorZuKlient("Du bist nicht Identifiziert.");
+						break;
+					}
+					klient->sendeEncrypted("\1", 1);
+					char typ = 0;
+					Text* info = is->zDB()->getInformationsText(&typ);
+					unsigned short len = info ? (unsigned short)info->getLength() : (unsigned short)0;
+					klient->sendeEncrypted((char*)&len, 2);
+					if (len > 0)
+						klient->sendeEncrypted(info->getText(), len);
+					klient->sendeEncrypted(&typ, 1);
+					if (info)
+						info->release();
+				}
+				break;
+			case 6: // frage, ob Spiel erlaubt ist
+				if (1)
+				{
+					if (!klientNummer)
+					{
+						errorZuKlient("Du bist nicht Identifiziert.");
+						break;
+					}
+					klient->sendeEncrypted("\1", 1);
+					int spielId = 0;
+					klient->getNachrichtEncrypted((char*)&spielId, 4);
+					if (is->zDB()->istSpielErlaubt(spielId))
+						klient->sendeEncrypted("\1", 1);
+					else
+						klient->sendeEncrypted("\0", 1);
+				}
+				break;
+			case 7: // frage, ob Karte erlaubt ist
+				if (1)
+				{
+					if (!klientNummer)
+					{
+						errorZuKlient("Du bist nicht Identifiziert.");
+						break;
+					}
+					klient->sendeEncrypted("\1", 1);
+					int karteId = 0;
+					klient->getNachrichtEncrypted((char*)&karteId, 4);
+					if (is->zDB()->istKarteErlaubt(karteId))
+						klient->sendeEncrypted("\1", 1);
+					else
+						klient->sendeEncrypted("\0", 1);
+				}
+				break;
+			case 8: // Frage nach Spiel Id
+				if (1)
+				{
+					if (!klientNummer)
+					{
+						errorZuKlient("Du bist nicht Identifiziert.");
+						break;
+					}
+					klient->sendeEncrypted("\1", 1);
+					unsigned char len = 0;
+					klient->getNachrichtEncrypted((char*)&len, 1);
+					char* name = new char[len + 1];
+					name[(int)len] = 0;
+					klient->getNachrichtEncrypted(name, len);
+					int id = is->zDB()->getSpielId(name);
+					klient->sendeEncrypted((char*)&id, 4);
+					delete[] name;
+				}
+				break;
+			case 9: // Frage nach Karte Id
+				if (1)
+				{
+					if (!klientNummer)
+					{
+						errorZuKlient("Du bist nicht Identifiziert.");
+						break;
+					}
+					klient->sendeEncrypted("\1", 1);
+					unsigned char len = 0;
+					klient->getNachrichtEncrypted((char*)&len, 1);
+					char* name = new char[len + 1];
+					name[(int)len] = 0;
+					klient->getNachrichtEncrypted(name, len);
+					int id = is->zDB()->getKarteId(name);
+					klient->sendeEncrypted((char*)&id, 4);
+					delete[] name;
+				}
+				break;
+			case 0xA: // Frage nach Account rufName
+				if (1)
+				{
+					if (!klientNummer)
+					{
+						errorZuKlient("Du bist nicht Identifiziert.");
+						break;
+					}
+					klient->sendeEncrypted("\1", 1);
+					int accountId = 0;
+					klient->getNachrichtEncrypted((char*)&accountId, 4);
+					Text* rName = is->zDB()->getAccountRufName(accountId);
+					if (rName)
+					{
+						char len = (char)rName->getLength();
+						klient->sendeEncrypted(&len, 1);
+						klient->sendeEncrypted(rName->getText(), len);
+						rName->release();
+					}
+					else
+						klient->sendeEncrypted("\0", 1);
+				}
+				break;
+			case 0xB: // Frage nach Spiel Statistik
+				if (1)
+				{
+					if (!klientNummer)
+					{
+						errorZuKlient("Du bist nicht Identifiziert.");
+						break;
+					}
+					klient->sendeEncrypted("\1", 1);
+					int accountId = 0;
+					int spielId = 0;
+					klient->getNachrichtEncrypted((char*)&accountId, 4);
+					klient->getNachrichtEncrypted((char*)&spielId, 4);
+					Array< int >* values = is->zDB()->getAccountSpielStatistik(accountId, spielId);
+					for (int i = 0; i < 10; i++)
+					{
+						int tmp = values ? values->get(i) : 0;
+						klient->sendeEncrypted((char*)&tmp, 4);
+					}
+					if (values)
+						values->release();
+				}
+				break;
+			case 0xC: // Frage nach Spieler Liste
+				if (!klientNummer)
+				{
+					errorZuKlient("Du bist nicht Identifiziert.");
+					break;
+				}
+				else
+				{
+					klient->sendeEncrypted("\1", 1);
+					unsigned char len = 0;
+					klient->getNachrichtEncrypted((char*)&len, 1);
+					char* suche = new char[len + 1];
+					suche[(int)len] = 0;
+					klient->getNachrichtEncrypted(suche, len);
+					int seite = 0;
+					klient->getNachrichtEncrypted((char*)&seite, 4);
+					char sortSpalte = 0;
+					char backwords = 0;
+					klient->getNachrichtEncrypted(&sortSpalte, 1);
+					klient->getNachrichtEncrypted(&backwords, 1);
+					int maxSeite = 0;
+					Result list = is->zDB()->getSpielerListe(suche, &seite, &maxSeite, sortSpalte, backwords != 0);
+					delete[] suche;
+					klient->sendeEncrypted((char*)&seite, 4);
+					klient->sendeEncrypted((char*)&maxSeite, 4);
+					klient->sendeEncrypted((char*)&list.zeilenAnzahl, 4);
+					for (int i = 0; i < list.zeilenAnzahl; i++)
+					{
+						int accId = (int)list.values[i * 6];
+						klient->sendeEncrypted((char*)&accId, 4);
+						len = (char)list.values[i * 6 + 1].getLength();
+						klient->sendeEncrypted((char*)&len, 1);
+						klient->sendeEncrypted(list.values[i * 6 + 1], len);
+						len = (char)list.values[i * 6 + 2].getLength();
+						klient->sendeEncrypted((char*)&len, 1);
+						klient->sendeEncrypted(list.values[i * 6 + 2], len);
+						len = (char)list.values[i * 6 + 3].getLength();
+						klient->sendeEncrypted((char*)&len, 1);
+						klient->sendeEncrypted(list.values[i * 6 + 3], len);
+						len = (char)list.values[i * 6 + 4].getLength();
+						klient->sendeEncrypted((char*)&len, 1);
+						klient->sendeEncrypted(list.values[i * 6 + 4], len);
+						len = (char)list.values[i * 6 + 5].getLength();
+						klient->sendeEncrypted((char*)&len, 1);
+						klient->sendeEncrypted(list.values[i * 6 + 5], len);
+					}
+					list.destroy();
+				}
+				break;
+			case 0xD: // Frage nach Gruppe Karte Id
+				if (1)
+				{
+					if (!klientNummer)
+					{
+						errorZuKlient("Du bist nicht Identifiziert.");
+						break;
+					}
+					klient->sendeEncrypted("\1", 1);
+					int gruppeId = 0;
+					klient->getNachrichtEncrypted((char*)&gruppeId, 4);
+					int karteId = is->zDB()->getGruppenKarteId(gruppeId);
+					klient->sendeEncrypted((char*)&karteId, 4);
+				}
+				break;
+			case 0xE: // Frage nach Karten Name
+				if (1)
+				{
+					if (!klientNummer)
+					{
+						errorZuKlient("Du bist nicht Identifiziert.");
+						break;
+					}
+					klient->sendeEncrypted("\1", 1);
+					int karteId = 0;
+					klient->getNachrichtEncrypted((char*)&karteId, 4);
+					Text* name = is->zDB()->getKarteName(karteId);
+					if (!name)
+					{
+						klient->sendeEncrypted("\0", 1);
+						break;
+					}
+					char len = (char)name->getLength();
+					klient->sendeEncrypted(&len, 1);
+					klient->sendeEncrypted(name->getText(), len);
+					name->release();
+				}
+				break;
+			case 0xF: // Frage nach Spiel Name
+				if (1)
+				{
+					if (!klientNummer)
+					{
+						errorZuKlient("Du bist nicht Identifiziert.");
+						break;
+					}
+					klient->sendeEncrypted("\1", 1);
+					int spielId = 0;
+					klient->getNachrichtEncrypted((char*)&spielId, 4);
+					Text* name = is->zDB()->getSpielName(spielId);
+					if (!name)
+					{
+						klient->sendeEncrypted("\0", 1);
+						break;
+					}
+					char len = (char)name->getLength();
+					klient->sendeEncrypted(&len, 1);
+					klient->sendeEncrypted(name->getText(), len);
+					name->release();
+				}
+				break;
+			case 0x10: // Frage nach Chatroom Name
+				if (1)
+				{
+					if (!klientNummer)
+					{
+						errorZuKlient("Du bist nicht Identifiziert.");
+						break;
+					}
+					klient->sendeEncrypted("\1", 1);
+					int chatroomId = 0;
+					klient->getNachrichtEncrypted((char*)&chatroomId, 4);
+					Text* name = is->zDB()->getChatroomName(chatroomId);
+					if (!name)
+					{
+						klient->sendeEncrypted("\0", 1);
+						break;
+					}
+					char len = (char)name->getLength();
+					klient->sendeEncrypted(&len, 1);
+					klient->sendeEncrypted(name->getText(), len);
+					name->release();
+				}
+				break;
+			case 0x11: // Frage nach Spiel Id
+				if (1)
+				{
+					if (!klientNummer)
+					{
+						errorZuKlient("Du bist nicht Identifiziert.");
+						break;
+					}
+					klient->sendeEncrypted("\1", 1);
+					int karteId = 0;
+					klient->getNachrichtEncrypted((char*)&karteId, 4);
+					int spielId = is->zDB()->getSpielId(karteId);
+					klient->sendeEncrypted((char*)&spielId, 4);
+				}
+				break;
+			case 0x12: // Frage nach Spieler Id
+				if (1)
+				{
+					if (!klientNummer)
+					{
+						errorZuKlient("Du bist nicht Identifiziert.");
+						break;
+					}
+					klient->sendeEncrypted("\1", 1);
+					unsigned char len = 0;
+					klient->getNachrichtEncrypted((char*)&len, 1);
+					if (len)
+					{
+						char* name = new char[len + 1];
+						name[(int)len] = 0;
+						klient->getNachrichtEncrypted(name, len);
+						int id = is->zDB()->getAccountId(name);
+						klient->sendeEncrypted((char*)&id, 4);
+						delete[]name;
+					}
+				}
+				break;
+			case 0x13: // Frage nach Chatroom Id
+				if (1)
+				{
+					if (!klientNummer)
+					{
+						errorZuKlient("Du bist nicht Identifiziert.");
+						break;
+					}
+					klient->sendeEncrypted("\1", 1);
+					unsigned char len = 0;
+					klient->getNachrichtEncrypted((char*)&len, 1);
+					if (len)
+					{
+						char* name = new char[len + 1];
+						name[(int)len] = 0;
+						klient->getNachrichtEncrypted(name, len);
+						int id = is->zDB()->getChatroomId(name);
+						klient->sendeEncrypted((char*)&id, 4);
+						delete[]name;
+					}
+				}
+				break;
+			case 0x14: // Frage nach Spiel Punkten
+				if (1)
+				{
+					if (!klientNummer)
+					{
+						errorZuKlient("Du bist nicht Identifiziert.");
+						break;
+					}
+					klient->sendeEncrypted("\1", 1);
+					int spielId = 0;
+					int accountId = 0;
+					klient->getNachrichtEncrypted((char*)&spielId, 4);
+					klient->getNachrichtEncrypted((char*)&accountId, 4);
+					int ret = is->zDB()->getSpielerPunkte(spielId, accountId);
+					klient->sendeEncrypted((char*)&ret, 4);
+				}
+				break;
+			case 0x15: // Frage nach Gruppe Administrator
+				if (1)
+				{
+					if (!klientNummer)
+					{
+						errorZuKlient("Du bist nicht Identifiziert.");
+						break;
+					}
+					klient->sendeEncrypted("\1", 1);
+					int gruppeId = 0;
+					klient->getNachrichtEncrypted((char*)&gruppeId, 4);
+					int ret = is->zDB()->getGruppeAdminId(gruppeId);
+					klient->sendeEncrypted((char*)&ret, 4);
+				}
+				break;
+			case 0x16: // Frage nach Spiel Liste
+				if (klientNummer)
+				{
+					klient->sendeEncrypted("\1", 1);
+					Array< int >* list = is->zDB()->getAccountSpielArtListe(klientNummer);
+					if (!list)
+					{
+						klient->sendeEncrypted("\0\0\0\0", 4);
+						break;
+					}
+					int anz = list->getEintragAnzahl();
+					klient->sendeEncrypted((char*)&anz, 4);
+					for (int i = 0; i < anz; i++)
+					{
+						int id = list->get(i);
+						klient->sendeEncrypted((char*)&id, 4);
+					}
+				}
+				else
+					errorZuKlient("Du bist nicht Identifiziert.");
+				break;
+			case 0x17: // Frage nach neuster Spiel Version
+				if (klientNummer)
+				{
+					klient->sendeEncrypted("\1", 1);
+					int id = 0;
+					klient->getNachrichtEncrypted((char*)&id, 4);
+					int v = is->zDB()->getNeusteSpielVersion(id);
+					klient->sendeEncrypted((char*)&v, 4);
+				}
+				else
+					errorZuKlient("Du bist nicht Identifiziert.");
+				break;
+			case 0x18: // Frage nach Kupfer
+				if (klientNummer)
+				{
+					klient->sendeEncrypted("\1", 1);
+					int k = is->zDB()->getKupfer(klientNummer);
+					klient->sendeEncrypted((char*)&k, 4);
+				}
+				else
+					errorZuKlient("Du bist nicht Identifiziert.");
+				break;
+			case 0x19: // Frage nach Dateigruppen Id von Spiel
+				if (klientNummer)
+				{
+					klient->sendeEncrypted("\1", 1);
+					int spielId = 0;
+					klient->getNachrichtEncrypted((char*)&spielId, 4);
+					int dgId = is->zDB()->getDateiGruppeVonSpiel(spielId);
+					klient->sendeEncrypted((char*)&dgId, 4);
+				}
+				else
+					errorZuKlient("Du bist nicht Identifiziert.");
+				break;
+			case 0x1A: // Frage nach Dateigruppen Pfad
+				if (klientNummer)
+				{
+					klient->sendeEncrypted("\1", 1);
+					int dgId = 0;
+					klient->getNachrichtEncrypted((char*)&dgId, 4);
+					Text* pf = is->zDB()->getDateiGruppePfad(dgId);
+					if (!pf)
+						errorZuKlient("Die Dateigruppe wurde nicht gefunden.");
+					else
+					{
+						klient->sendeEncrypted("\1", 1);
+						char len = (char)pf->getLength();
+						klient->sendeEncrypted(&len, 1);
+						if (len)
+							klient->sendeEncrypted(pf->getText(), len);
+						pf->release();
+					}
+				}
+				else
+					errorZuKlient("Du bist nicht Identifiziert.");
+				break;
+			case 0x1B: // Frage nach karte Liste
+				if (klientNummer)
+				{
+					klient->sendeEncrypted("\1", 1);
+					int spielId = 0;
+					klient->getNachrichtEncrypted((char*)&spielId, 4);
+					Array< int >* list = is->zDB()->getAccountKarteListe(klientNummer, spielId);
+					if (!list)
+					{
+						klient->sendeEncrypted("\0\0\0\0", 4);
+						break;
+					}
+					int anz = list->getEintragAnzahl();
+					klient->sendeEncrypted((char*)&anz, 4);
+					for (int i = 0; i < anz; i++)
+					{
+						int id = list->get(i);
+						klient->sendeEncrypted((char*)&id, 4);
+					}
+				}
+				else
+					errorZuKlient("Du bist nicht Identifiziert.");
+				break;
+			case 0x1E: // Frage nach Gruppe Spieler Hinzufügen
+				if (klientNummer)
+				{
+					klient->sendeEncrypted("\1", 1);
+					int gruppeId = 0;
+					klient->getNachrichtEncrypted((char*)&gruppeId, 4);
+					char gSH = (char)is->zDB()->getGruppeSpielerAdd(gruppeId);
+					klient->sendeEncrypted(&gSH, 1);
+				}
+				else
+					errorZuKlient("Du bist nicht Identifiziert.");
+				break;
+			case 0x1F: // Frage nach Spieler Aktivität
+				if (klientNummer)
+				{
+					klient->sendeEncrypted("\1", 1);
+					int acc = 0;
+					klient->getNachrichtEncrypted((char*)&acc, 4);
+					RCArray< Text >* datum = new RCArray< Text >();
+					Array< double >* stOnline = new Array< double >();
+					Array< double >* stSpiel = new Array< double >();
+					Array< int >* anzSpiele = new Array< int >();
+					Array< int >* anzGewonnen = new Array< int >();
+					if (is->zDB()->getSpielerAktivity(acc, datum, stOnline, stSpiel, anzSpiele, anzGewonnen))
+					{
+						klient->sendeEncrypted("\1", 1);
+						int anz = datum->getEintragAnzahl();
+						for (int i = 0; i < anz; i++)
+						{
+							if (datum->z(i))
+							{
+								char len = (char)datum->get(i)->getLength();
+								if (len)
+								{
+									klient->sendeEncrypted(&len, 1);
+									klient->sendeEncrypted(datum->z(i)->getText(), len);
+									double sto = stOnline->hat(i) ? stOnline->get(i) : 0;
+									klient->sendeEncrypted((char*)&sto, 8);
+									double sts = stSpiel->hat(i) ? stSpiel->get(i) : 0;
+									klient->sendeEncrypted((char*)&sts, 8);
+									int anzs = anzSpiele->hat(i) ? anzSpiele->get(i) : 0;
+									klient->sendeEncrypted((char*)&anzs, 4);
+									int anzg = anzGewonnen->hat(i) ? anzGewonnen->get(i) : 0;
+									klient->sendeEncrypted((char*)&anzg, 4);
+								}
+							}
+						}
+						klient->sendeEncrypted("\0", 1);
+					}
+					else
+						errorZuKlient("Keine Daten gefunden.");
+					datum->release();
+					stOnline->release();
+					stSpiel->release();
+					anzSpiele->release();
+					anzGewonnen->release();
+				}
+				else
+					errorZuKlient("Du bist nicht Identifiziert.");
+				break;
+			case 0x20: // Frage nach Anzahl der gespielten Spiele von Karte
+				if (klientNummer)
+				{
+					klient->sendeEncrypted("\1", 1);
+					int acc = 0;
+					int karte = 0;
+					klient->getNachrichtEncrypted((char*)&acc, 4);
+					klient->getNachrichtEncrypted((char*)&karte, 4);
+					int anz = is->zDB()->getAccountKarteSpiele(acc, karte);
+					klient->sendeEncrypted((char*)&anz, 4);
+				}
+				else
+					errorZuKlient("Du bist nicht Identifiziert.");
+				break;
+			case 0x21: // Frage nach Anzahl gewonnener Spiele von Karte
+				if (klientNummer)
+				{
+					klient->sendeEncrypted("\1", 1);
+					int acc = 0;
+					int karte = 0;
+					klient->getNachrichtEncrypted((char*)&acc, 4);
+					klient->getNachrichtEncrypted((char*)&karte, 4);
+					int anz = is->zDB()->getAccountKarteSpieleGewonnen(acc, karte);
+					klient->sendeEncrypted((char*)&anz, 4);
+				}
+				else
+					errorZuKlient("Du bist nicht Identifiziert.");
+				break;
+			case 0x22: // Frage nach Besitz Status von Karte
+				if (klientNummer)
+				{
+					klient->sendeEncrypted("\1", 1);
+					int acc = 0;
+					int karte = 0;
+					klient->getNachrichtEncrypted((char*)&acc, 4);
+					klient->getNachrichtEncrypted((char*)&karte, 4);
+					char status = (char)is->zDB()->hatAccountKarte(acc, karte);
+					klient->sendeEncrypted(&status, 1);
+				}
+				else
+					errorZuKlient("Du bist nicht Identifiziert.");
+				break;
+			case 0x23: // Frage nach Besitz Status von Spiel
+				if (klientNummer)
+				{
+					klient->sendeEncrypted("\1", 1);
+					int acc = 0;
+					int spiel = 0;
+					klient->getNachrichtEncrypted((char*)&acc, 4);
+					klient->getNachrichtEncrypted((char*)&spiel, 4);
+					char status = (char)is->zDB()->hatAccountSpiel(acc, spiel);
+					klient->sendeEncrypted(&status, 1);
+				}
+				else
+					errorZuKlient("Du bist nicht Identifiziert.");
+				break;
+			case 0x24: // Frage nach Liste mit gespielten Karten
+				if (klientNummer)
+				{
+					klient->sendeEncrypted("\1", 1);
+					int acc = 0;
+					int spiel = 0;
+					klient->getNachrichtEncrypted((char*)&acc, 4);
+					klient->getNachrichtEncrypted((char*)&spiel, 4);
+					Array< int >* res = is->zDB()->getAccountKarteGespieltListe(acc, spiel);
+					if (res)
+					{
+						int anz = res->getEintragAnzahl();
+						klient->sendeEncrypted((char*)&anz, 4);
+						for (int i = 0; i < anz; i++)
+						{
+							int val = res->get(i);
+							klient->sendeEncrypted((char*)&val, 4);
+						}
+						res->release();
+					}
+					else
+						klient->sendeEncrypted("\0\0\0\0", 4);
+				}
+				else
+					errorZuKlient("Du bist nicht Identifiziert.");
+				break;
+			case 0x25: // Frage nach Liste mit gespielten Spielen
+				if (klientNummer)
+				{
+					klient->sendeEncrypted("\1", 1);
+					int acc = 0;
+					klient->getNachrichtEncrypted((char*)&acc, 4);
+					Array< int >* res = is->zDB()->getAccountSpielGespieltListe(acc);
+					if (res)
+					{
+						int anz = res->getEintragAnzahl();
+						klient->sendeEncrypted((char*)&anz, 4);
+						for (int i = 0; i < anz; i++)
+						{
+							int val = res->get(i);
+							klient->sendeEncrypted((char*)&val, 4);
+						}
+						res->release();
+					}
+					else
+						klient->sendeEncrypted("\0\0\0\0", 4);
+				}
+				else
+					errorZuKlient("Du bist nicht Identifiziert.");
+				break;
+			case 0x26: // Frage nach Liste mit spiel Partnern
+				if (klientNummer)
+				{
+					klient->sendeEncrypted("\1", 1);
+					int acc = 0;
+					klient->getNachrichtEncrypted((char*)&acc, 4);
+					Result res = is->zDB()->getSpielPartnerListe(acc);
+					klient->sendeEncrypted((char*)&res.zeilenAnzahl, 4);
+					for (int i = 0; i < res.zeilenAnzahl; i++)
+					{
+						int spieler = (int)res.values[i * 3];
+						int anzahl = (int)res.values[i * 3 + 1];
+						int karte = (int)res.values[i * 3 + 2];
+						klient->sendeEncrypted((char*)&spieler, 4);
+						klient->sendeEncrypted((char*)&karte, 4);
+						klient->sendeEncrypted((char*)&anzahl, 4);
+					}
+					res.destroy();
+				}
+				else
+					errorZuKlient("Du bist nicht Identifiziert.");
+				break;
+			case 0x27: // Frage nach Liste mit spiel Statistiken
+				if (klientNummer)
+				{
+					klient->sendeEncrypted("\1", 1);
+					int acc = 0;
+					klient->getNachrichtEncrypted((char*)&acc, 4);
+					int seite = 0;
+					klient->getNachrichtEncrypted((char*)&seite, 4);
+					char sortSpalte = 0;
+					char backwords = 0;
+					klient->getNachrichtEncrypted(&sortSpalte, 1);
+					klient->getNachrichtEncrypted(&backwords, 1);
+					int maxSeite = 0;
+					Result list = is->zDB()->getSpielStatistikListe(acc, &seite, &maxSeite, sortSpalte, backwords != 0);
+					klient->sendeEncrypted((char*)&seite, 4);
+					klient->sendeEncrypted((char*)&maxSeite, 4);
+					klient->sendeEncrypted((char*)&list.zeilenAnzahl, 4);
+					klient->sendeEncrypted((char*)&list.feldAnzahl, 4);
+					for (int i = 0; i < list.zeilenAnzahl; i++)
+					{
+						for (int j = 0; j < list.feldAnzahl; j++)
+						{
+							if (j != 1)
+							{
+								int val = (int)list.values[j + i * list.feldAnzahl];
+								klient->sendeEncrypted((char*)&val, 4);
+							}
+							else
+							{
+								char len = (char)(list.values[j + i * list.feldAnzahl].getLength());
+								klient->sendeEncrypted(&len, 1);
+								if (len)
+									klient->sendeEncrypted(list.values[j + i * list.feldAnzahl], len);
+							}
+						}
+					}
+					list.destroy();
+				}
+				else
+					errorZuKlient("Du bist nicht Identifiziert.");
+				break;
+			case 0x28: // Spiel Historie Liste
+				if (klientNummer)
+				{
+					klient->sendeEncrypted("\1", 1);
+					int acc = 0;
+					klient->getNachrichtEncrypted((char*)&acc, 4);
+					AHDaten* daten = is->zDB()->getSpielHistorie(acc, is);
+					if (daten)
+					{
+						char anz = (char)daten->spiele->getEintragAnzahl();
+						klient->sendeEncrypted(&anz, 1);
+						for (char i = 0; i < anz; i++)
+						{
+							AHSpielDaten* spiel = daten->spiele->z(i);
+							klient->sendeEncrypted((char*)&spiel->id, 4);
+							klient->sendeEncrypted((char*)&spiel->karteId, 4);
+							char len = (char)spiel->spiel->getLength();
+							klient->sendeEncrypted(&len, 1);
+							if (len)
+								klient->sendeEncrypted(*spiel->spiel, len);
+							len = (char)spiel->karte->getLength();
+							klient->sendeEncrypted(&len, 1);
+							if (len)
+								klient->sendeEncrypted(*spiel->karte, len);
+							len = (char)spiel->datum->getLength();
+							klient->sendeEncrypted(&len, 1);
+							if (len)
+								klient->sendeEncrypted(*spiel->datum, len);
+							len = (char)spiel->status->getLength();
+							klient->sendeEncrypted(&len, 1);
+							if (len)
+								klient->sendeEncrypted(*spiel->status, len);
+							len = (char)spiel->dauer->getLength();
+							klient->sendeEncrypted(&len, 1);
+							if (len)
+								klient->sendeEncrypted(*spiel->dauer, len);
+							len = (char)spiel->spielStatus->getLength();
+							klient->sendeEncrypted(&len, 1);
+							if (len)
+								klient->sendeEncrypted(*spiel->spielStatus, len);
+							len = (char)spiel->gewinner->getLength();
+							klient->sendeEncrypted(&len, 1);
+							if (len)
+								klient->sendeEncrypted(*spiel->gewinner, len);
+							klient->sendeEncrypted((char*)&spiel->sAnzahl, 4);
+							char tAnz = (char)spiel->teams->getEintragAnzahl();
+							klient->sendeEncrypted(&tAnz, 1);
+							for (char j = 0; j < tAnz; j++)
+							{
+								AHSpielTeamDaten* team = spiel->teams->z(j);
+								char len = (char)team->name->getLength();
+								klient->sendeEncrypted(&len, 1);
+								if (len)
+									klient->sendeEncrypted(*team->name, len);
+								klient->sendeEncrypted((char*)&team->sAnzahl, 4);
+								len = (char)team->status->getLength();
+								klient->sendeEncrypted(&len, 1);
+								if (len)
+									klient->sendeEncrypted(*team->status, len);
+								klient->sendeEncrypted((char*)&team->farbe, 4);
+								char sAnz = (char)team->spieler->getEintragAnzahl();
+								klient->sendeEncrypted(&sAnz, 1);
+								for (char k = 0; k < sAnz; k++)
+								{
+									AHSpielSpielerDaten* spieler = team->spieler->z(k);
+									char len = (char)spieler->name->getLength();
+									klient->sendeEncrypted(&len, 1);
+									if (len)
+										klient->sendeEncrypted(*spieler->name, len);
+									klient->sendeEncrypted((char*)&spieler->punkte, 4);
+									len = (char)spieler->status->getLength();
+									klient->sendeEncrypted(&len, 1);
+									if (len)
+										klient->sendeEncrypted(*spieler->status, len);
+									klient->sendeEncrypted((char*)&spieler->farbe, 4);
+								}
+							}
+						}
+						daten->release();
+					}
+					else
+						klient->sendeEncrypted("\0", 1);
+				}
+				else
+					errorZuKlient("Du bist nicht Identifiziert.");
+				break;
+			case 0x29: // Frage nach Historie Server
+				if (klientNummer)
+				{
+					klient->sendeEncrypted("\1", 1);
+					int spielId = 0;
+					klient->getNachrichtEncrypted((char*)&spielId, 4);
+					int port = 0;
+					Text* ip = new Text();
+					if (is->zDB()->getHistorieServerPortIp(klientNummer, spielId, &port, ip))
+					{
+						klient->sendeEncrypted("\1", 1);
+						klient->sendeEncrypted((char*)&port, 4);
+						char len = (char)ip->getLength();
+						klient->sendeEncrypted(&len, 1);
+						klient->sendeEncrypted(*ip, len);
+					}
+					else
+						errorZuKlient("Die Daten für dieses Spiel sind vorrübergehend nicht verfügbar.");
+					ip->release();
+				}
+				else
+					errorZuKlient("Du bist nicht Identifiziert.");
+				break;
+			case 0x2A: // Frage nach Dateigruppen Id von Pfad
+				if (klientNummer)
+				{
+					klient->sendeEncrypted("\1", 1);
+					unsigned char len = 0;
+					klient->getNachrichtEncrypted((char*)&len, 1);
+					char* pf = new char[len + 1];
+					pf[(int)len] = 0;
+					klient->getNachrichtEncrypted((char*)pf, len);
+					int dgId = is->zDB()->getDateiGruppeVonPfad(pf);
+					delete[] pf;
+					klient->sendeEncrypted((char*)&dgId, 4);
+				}
+				else
+					errorZuKlient("Du bist nicht Identifiziert.");
+				break;
+			case 0x2B: // Frage nach neuster Version einer Dateigruppe
+				if (klientNummer)
+				{
+					klient->sendeEncrypted("\1", 1);
+					int dg = 0;
+					klient->getNachrichtEncrypted((char*)&dg, 4);
+					int v = is->zDB()->getNeusteDateiGruppe(dg);
+					klient->sendeEncrypted((char*)&v, 4);
+				}
+				else
+					errorZuKlient("Du bist nicht Identifiziert.");
+				break;
+			case 0x2C: // ping
+				if (1)
+				{
+					if (!klientNummer)
+					{
+						errorZuKlient("Du bist nicht Identifiziert.");
+						break;
+					}
+					klient->sendeEncrypted("\1", 1);
+				}
+				break;
+			case 0x2D: // Hat Account Recht
+				if (!klientNummer)
+				{
+					errorZuKlient("Du bist nicht Identifiziert.");
+					break;
+				}
+				else
+				{
+					klient->sendeEncrypted("\1", 1);
+					int recht = 0;
+					klient->getNachrichtEncrypted((char*)&recht, 4);
+					if (is->zDB()->hatKlientRecht(klientNummer, recht))
+						klient->sendeEncrypted("\1", 1);
+					else
+						klient->sendeEncrypted("\0", 1);
+				}
+				break;
+			case 0x2E: // Karten Liste
+				if (!klientNummer)
+				{
+					errorZuKlient("Du bist nicht Identifiziert.");
+					break;
+				}
+				else
+				{
+					klient->sendeEncrypted("\1", 1);
+					unsigned char filterLen = 0;
+					klient->getNachrichtEncrypted((char*)&filterLen, 1);
+					char* filter = new char[filterLen + 1];
+					filter[(int)filterLen] = 0;
+					if (filterLen)
+						klient->getNachrichtEncrypted(filter, filterLen);
+					char sortSpalte = 0;
+					klient->getNachrichtEncrypted(&sortSpalte, 1);
+					char sortRichtung = 0;
+					klient->getNachrichtEncrypted(&sortRichtung, 1);
+					Result res = is->zDB()->getKartenListe(klientNummer, filter, sortSpalte, sortRichtung);
+					delete[] filter;
+					klient->sendeEncrypted((char*)&res.zeilenAnzahl, 4);
+					for (int i = 0; i < res.zeilenAnzahl; i++)
+					{
+						int val = (int)res.values[i * 6];
+						klient->sendeEncrypted((char*)&val, 4);
+						char len = (char)res.values[i * 6 + 1].getLength();
+						klient->sendeEncrypted(&len, 1);
+						if (len)
+							klient->sendeEncrypted(res.values[i * 6 + 1], len);
+						len = (char)res.values[i * 6 + 2].getLength();
+						klient->sendeEncrypted(&len, 1);
+						if (len)
+							klient->sendeEncrypted(res.values[i * 6 + 2], len);
+						val = (int)res.values[i * 6 + 3];
+						klient->sendeEncrypted((char*)&val, 4);
+						val = (int)res.values[i * 6 + 4];
+						klient->sendeEncrypted((char*)&val, 4);
+						val = (int)res.values[i * 6 + 5];
+						klient->sendeEncrypted((char*)&val, 4);
+					}
+					res.destroy();
+				}
+				break;
+			case 0x2F: // Editor Server Anfrage
+				if (!klientNummer)
+				{
+					errorZuKlient("Du bist nicht Identifiziert.");
+					break;
+				}
+				else
+				{
+					klient->sendeEncrypted("\1", 1);
+					int karteId = 0;
+					klient->getNachrichtEncrypted((char*)&karteId, 4);
+					int port = 0;
+					Text ip;
+					if (!is->zDB()->getEditorServerPortIp(klientNummer, karteId, &port, &ip))
+					{
+						errorZuKlient("Du kannst diese Karte momentan nicht abrufen.");
+						break;
+					}
+					klient->sendeEncrypted("\1", 1);
+					klient->sendeEncrypted((char*)&port, 4);
+					char len = (char)ip.getLength();
+					klient->sendeEncrypted(&len, 1);
+					klient->sendeEncrypted(ip, len);
+				}
+				break;
+			case 0x30: // Karten Server Anfrage
+				if (!klientNummer)
+				{
+					errorZuKlient("Du bist nicht Identifiziert.");
+					break;
+				}
+				else
+				{
+					klient->sendeEncrypted("\1", 1);
+					int karteId = 0;
+					klient->getNachrichtEncrypted((char*)&karteId, 4);
+					int port = 0;
+					Text ip;
+					if (!is->zDB()->getKartenServerPortIp(klientNummer, karteId, &port, &ip))
+					{
+						errorZuKlient("Diese Karte ist vorrübergehend nicht erreichbar.");
+						break;
+					}
+					klient->sendeEncrypted("\1", 1);
+					klient->sendeEncrypted((char*)&port, 4);
+					char len = (char)ip.getLength();
+					klient->sendeEncrypted(&len, 1);
+					klient->sendeEncrypted(ip, len);
+				}
+				break;
+			default:
+				errorZuKlient("Unbekannte Nachricht!");
+				break;
+			}
+			if (br)
+				break;
+			is->addEmpfangen(klient->getDownloadBytes(1));
+			is->addGesendet(klient->getUploadBytes(1));
+		}
+	}
+	is->addEmpfangen(klient->getDownloadBytes(1));
+	is->addGesendet(klient->getUploadBytes(1));
+	is->removeKlient(this); // delete this
 }
 
 // constant
-void ISKlient::errorZuKlient( const char* nachricht ) const // sendet eine Fehlernachricht zum Klient
+void ISKlient::errorZuKlient(const char* nachricht) const // sendet eine Fehlernachricht zum Klient
 {
-    klient->sendeEncrypted( "\3", 1 );
-    char len = (char)textLength( nachricht );
-    klient->sendeEncrypted( &len, 1 );
-    klient->sendeEncrypted( nachricht, len );
+	klient->sendeEncrypted("\3", 1);
+	char len = (char)textLength(nachricht);
+	klient->sendeEncrypted(&len, 1);
+	klient->sendeEncrypted(nachricht, len);
 }
 
 int ISKlient::getKlientNummer() const // gibt die KlientId zurück
 {
-    return klientNummer;
+	return klientNummer;
 }

InformationServer/InformationServer.h

@@ -16,13 +16,13 @@ class ISKlient;
 class InformationServer : public Thread
 {
 private:
-	Server *server;
-	SSLServer *aServer;
-	InitDatei *ini;
-	ISDatenbank *db;
+	Server* server;
+	SSLServer* aServer;
+	InitDatei* ini;
+	ISDatenbank* db;
 	CRITICAL_SECTION cs;
-	RCArray< ISKlient > *klients;
-	Text *fehler;
+	RCArray< ISKlient >* klients;
+	Text* fehler;
 	int id;
 	bool nichtPausiert;
 	int empfangen;
@@ -31,7 +31,7 @@ private:
 
 public:
 	// Konstruktor 
-	InformationServer( InitDatei *zIni );
+	InformationServer(InitDatei* zIni);
 	// Destruktor 
 	virtual ~InformationServer();
 	// nicht constant 
@@ -42,56 +42,56 @@ public:
 	bool serverPause();
 	bool serverFortsetzen();
 	bool serverBeenden();
-	bool setMaxKlients( int mc );
-	bool absturzKlient( int klientId );
-	bool removeKlient( ISKlient *zKlient );
-	void addGesendet( int bytes );
-	void addEmpfangen( int bytes );
+	bool setMaxKlients(int mc);
+	bool absturzKlient(int klientId);
+	bool removeKlient(ISKlient* zKlient);
+	void addGesendet(int bytes);
+	void addEmpfangen(int bytes);
 	// conatant 
 	bool istAn() const;
-	Server *zServer() const;
-	ISDatenbank *zDB() const;
+	Server* zServer() const;
+	ISDatenbank* zDB() const;
 	bool hatClients() const;
 	int getId() const;
-	char *getLetzterFehler( ) const;
+	const char* getLetzterFehler() const;
 };
 
 class ISAKlient : public Thread
 {
 private:
-	SSLSKlient *klient;
-	Text *name;
-	Text *passwort;
+	SSLSKlient* klient;
+	Text* name;
+	Text* passwort;
 	int adminId;
-	InformationServer *is;
+	InformationServer* is;
 
 public:
 	// Konstruktor 
-	ISAKlient( SSLSKlient *klient, InformationServer *is );
+	ISAKlient(SSLSKlient* klient, InformationServer* is);
 	// Destruktor 
-	virtual ~ISAKlient( );
+	virtual ~ISAKlient();
 	// nicht constant
-	void thread( );
-	void errorZuKlient( const char *nachricht ) const; // sendet eine Fehlernachricht zum AKlient
+	void thread();
+	void errorZuKlient(const char* nachricht) const; // sendet eine Fehlernachricht zum AKlient
 };
 
 class ISKlient : public Thread
 {
 private:
-	SKlient     *klient;
+	SKlient* klient;
 	unsigned int klientNummer;
-	InformationServer *is;
+	InformationServer* is;
 
 public:
 	// Konstruktor 
-	ISKlient( SKlient *klient, InformationServer *is );
+	ISKlient(SKlient* klient, InformationServer* is);
 	// Destruktor 
 	virtual ~ISKlient();
 	// nicht constant
 	void absturz();
 	void thread();
 	// constant
-	void errorZuKlient( const char *nachricht ) const; // sendet eine Fehlernachricht zum Klient
+	void errorZuKlient(const char* nachricht) const; // sendet eine Fehlernachricht zum Klient
 	int getKlientNummer() const;
 };
 

InformationServer/KartenLeser.cpp

@@ -5,159 +5,159 @@
 
 // Inhalt der KartenLeser Klasse aus KartenLeser.h
 // Konstruktor 
-KartenLeser::KartenLeser( int karteId, InformationServer *is )
-    : ReferenceCounter()
+KartenLeser::KartenLeser(int karteId, InformationServer* is)
+	: ReferenceCounter()
 {
-    pfad = new Text( "" );
-    *pfad += karteId;
-    while( DateiExistiert( pfad->getText() ) )
-        pfad->append( "_" );
-    Text ip;
-    int port;
-    is->zDB()->getKartenServerPortIp( 0, karteId, &port, &ip );
-    Klient *klient = new Klient();
-    unsigned char key[ 20 ] = { 24, 15, 53, 87, 38, 73, 154, 38, 246, 90, 39, 133, 11, 199, 22, 80, 26, 132, 95, 54 };
-    klient->setSendeKey( (char *)key, 20 );
-    klient->setEmpfangKey( (char *)key, 20 );
-    if( !klient->verbinde( (unsigned short)port, ip ) )
-    {
-        klient = (Klient *)klient->release();
-        return;
-    }
-    klient->sendeEncrypted( "\x7", 1 );
-    char ret = 0;
-    klient->getNachrichtEncrypted( &ret, 1 );
-    if( ret == 1 )
-    {
-        klient->sendeEncrypted( (char *)&karteId, 4 );
-        klient->getNachrichtEncrypted( &ret, 1 );
-        if( ret == 1 )
-        {
-            int anz = 0;
-            klient->getNachrichtEncrypted( (char *)&anz, 4 );
-            for( int i = 0; i < anz; i++ )
-            {
-                unsigned char len = 0;
-                klient->getNachrichtEncrypted( (char *)&len, 1 );
-                if( !len )
-                    continue;
-                char *pfa = new char[ len + 1 ];
-                pfa[ (int)len ] = 0;
-                klient->getNachrichtEncrypted( pfa, len );
-                __int64 size = 0;
-                klient->getNachrichtEncrypted( (char *)&size, 8 );
-                char *buffer = new char[ 2048 ];
-                Text pf = pfad->getText();
-                pf += "/";
-                pf += pfa;
-                delete[] pfa;
-                Datei d;
-                d.setDatei( pf );
-                d.erstellen();
-                d.open( Datei::Style::schreiben );
-                while( size )
-                {
-                    int l = size >= 2048 ? 2048 : (int)size;
-                    klient->getNachricht( buffer, l );
-                    d.schreibe( buffer, l );
-                    size -= l;
-                }
-                d.close();
-                delete[] buffer;
-            }
-        }
-    }
-    if( ret == 3 )
-    {
-        unsigned char byte = 0;
-        klient->getNachrichtEncrypted( (char *)&byte, 1 );
-        char *f = new char[ byte + 1 ];
-        f[ (int)byte ] = 0;
-        klient->getNachrichtEncrypted( f, byte );
-        delete[] f;
-    }
-    klient->sendeEncrypted( "\3", 1 );
-    klient->getNachrichtEncrypted( &ret, 1 );
-    klient->trenne();
-    klient->release();
+	pfad = new Text("");
+	*pfad += karteId;
+	while (DateiExistiert(pfad->getText()))
+		pfad->append("_");
+	Text ip;
+	int port;
+	is->zDB()->getKartenServerPortIp(0, karteId, &port, &ip);
+	Klient* klient = new Klient();
+	unsigned char key[20] = { 24, 15, 53, 87, 38, 73, 154, 38, 246, 90, 39, 133, 11, 199, 22, 80, 26, 132, 95, 54 };
+	klient->setSendeKey((char*)key, 20);
+	klient->setEmpfangKey((char*)key, 20);
+	if (!klient->verbinde((unsigned short)port, ip))
+	{
+		klient = (Klient*)klient->release();
+		return;
+	}
+	klient->sendeEncrypted("\x7", 1);
+	char ret = 0;
+	klient->getNachrichtEncrypted(&ret, 1);
+	if (ret == 1)
+	{
+		klient->sendeEncrypted((char*)&karteId, 4);
+		klient->getNachrichtEncrypted(&ret, 1);
+		if (ret == 1)
+		{
+			int anz = 0;
+			klient->getNachrichtEncrypted((char*)&anz, 4);
+			for (int i = 0; i < anz; i++)
+			{
+				unsigned char len = 0;
+				klient->getNachrichtEncrypted((char*)&len, 1);
+				if (!len)
+					continue;
+				char* pfa = new char[len + 1];
+				pfa[(int)len] = 0;
+				klient->getNachrichtEncrypted(pfa, len);
+				__int64 size = 0;
+				klient->getNachrichtEncrypted((char*)&size, 8);
+				char* buffer = new char[2048];
+				Text pf = pfad->getText();
+				pf += "/";
+				pf += pfa;
+				delete[] pfa;
+				Datei d;
+				d.setDatei(pf);
+				d.erstellen();
+				d.open(Datei::Style::schreiben);
+				while (size)
+				{
+					int l = size >= 2048 ? 2048 : (int)size;
+					klient->getNachricht(buffer, l);
+					d.schreibe(buffer, l);
+					size -= l;
+				}
+				d.close();
+				delete[] buffer;
+			}
+		}
+	}
+	if (ret == 3)
+	{
+		unsigned char byte = 0;
+		klient->getNachrichtEncrypted((char*)&byte, 1);
+		char* f = new char[byte + 1];
+		f[(int)byte] = 0;
+		klient->getNachrichtEncrypted(f, byte);
+		delete[] f;
+	}
+	klient->sendeEncrypted("\3", 1);
+	klient->getNachrichtEncrypted(&ret, 1);
+	klient->trenne();
+	klient->release();
 }
 
 // Destruktor
 KartenLeser::~KartenLeser()
 {
-    DateiRemove( pfad );
+	DateiRemove(pfad);
 }
 
 // nicht constant
-bool KartenLeser::ladeSpielerTeamStruktur( SpielerTeamStruktur *sts )
+bool KartenLeser::ladeSpielerTeamStruktur(SpielerTeamStruktur* sts)
 {
-    if( !pfad->getLength() )
-        return 0;
-    Text *pf = new Text( pfad->getText() );
-    pf->append( "/sts.ltgd" );
-    Datei *datei = new Datei();
-    datei->setDatei( pf );
-    if( !datei->existiert() || datei->istOrdner() )
-    {
-        datei->release();
-        return 0;
-    }
-    datei->open( Datei::Style::lesen );
-    datei->lese( (char *)&sts->spielerAnzahl, 4 );
-    datei->lese( (char *)&sts->teamAnzahl, 4 );
-    if( sts->spielerFarbe )
-        sts->spielerFarbe->release();
-    sts->spielerFarbe = new Array< int >();
-    for( int i = 0; i < sts->spielerAnzahl; i++ )
-    {
-        int farbe = 0;
-        datei->lese( (char *)&farbe, 4 );
-        sts->spielerFarbe->add( farbe );
-    }
-    if( sts->teamFarbe )
-        sts->teamFarbe->release();
-    sts->teamFarbe = new Array< int >();
-    for( int i = 0; i < sts->teamAnzahl; i++ )
-    {
-        int farbe = 0;
-        datei->lese( (char *)&farbe, 4 );
-        sts->teamFarbe->add( farbe );
-    }
-    if( sts->teamName )
-        sts->teamName->release();
-    sts->teamName = new RCArray< Text >();
-    for( int i = 0; i < sts->teamAnzahl; i++ )
-    {
-        unsigned char len = 0;
-        datei->lese( (char *)&len, 1 );
-        char *txt = new char[ len + 1 ];
-        txt[ (int)len ] = 0;
-        datei->lese( txt, len );
-        Text *name = new Text( txt );
-        delete[] txt;
-        sts->teamName->add( name );
-    }
-    if( sts->teamSize )
-        sts->teamSize->release();
-    sts->teamSize = new Array< int >();
-    for( int i = 0; i < sts->teamAnzahl; i++ )
-    {
-        int size = 0;
-        datei->lese( (char *)&size, 4 );
-        sts->teamSize->add( size );
-    }
-    datei->close();
-    datei->release();
-    return 1;
+	if (!pfad->getLength())
+		return 0;
+	Text* pf = new Text(pfad->getText());
+	pf->append("/sts.ltgd");
+	Datei* datei = new Datei();
+	datei->setDatei(pf);
+	if (!datei->existiert() || datei->istOrdner())
+	{
+		datei->release();
+		return 0;
+	}
+	datei->open(Datei::Style::lesen);
+	datei->lese((char*)&sts->spielerAnzahl, 4);
+	datei->lese((char*)&sts->teamAnzahl, 4);
+	if (sts->spielerFarbe)
+		sts->spielerFarbe->release();
+	sts->spielerFarbe = new Array< int >();
+	for (int i = 0; i < sts->spielerAnzahl; i++)
+	{
+		int farbe = 0;
+		datei->lese((char*)&farbe, 4);
+		sts->spielerFarbe->add(farbe);
+	}
+	if (sts->teamFarbe)
+		sts->teamFarbe->release();
+	sts->teamFarbe = new Array< int >();
+	for (int i = 0; i < sts->teamAnzahl; i++)
+	{
+		int farbe = 0;
+		datei->lese((char*)&farbe, 4);
+		sts->teamFarbe->add(farbe);
+	}
+	if (sts->teamName)
+		sts->teamName->release();
+	sts->teamName = new RCArray< Text >();
+	for (int i = 0; i < sts->teamAnzahl; i++)
+	{
+		unsigned char len = 0;
+		datei->lese((char*)&len, 1);
+		char* txt = new char[len + 1];
+		txt[(int)len] = 0;
+		datei->lese(txt, len);
+		Text* name = new Text(txt);
+		delete[] txt;
+		sts->teamName->add(name);
+	}
+	if (sts->teamSize)
+		sts->teamSize->release();
+	sts->teamSize = new Array< int >();
+	for (int i = 0; i < sts->teamAnzahl; i++)
+	{
+		int size = 0;
+		datei->lese((char*)&size, 4);
+		sts->teamSize->add(size);
+	}
+	datei->close();
+	datei->release();
+	return 1;
 }
 
 // constant
-Text *KartenLeser::getPfad() const
+Text* KartenLeser::getPfad() const
 {
-    return pfad ? dynamic_cast<Text *>( pfad->getThis() ) : 0;
+	return pfad ? dynamic_cast<Text*>(pfad->getThis()) : 0;
 }
 
-Text *KartenLeser::zPfad() const
+Text* KartenLeser::zPfad() const
 {
-    return pfad;
+	return pfad;
 }

InformationServer/KartenLeser.h

@@ -11,18 +11,18 @@ struct SpielerTeamStruktur;
 class KartenLeser : public virtual ReferenceCounter
 {
 private:
-    Text *pfad;
+	Text* pfad;
 
 public:
-    // Konstruktor 
-    KartenLeser( int karteId, InformationServer *is );
-    // Destruktor
-    ~KartenLeser();
-    // nicht constant
-    bool ladeSpielerTeamStruktur( SpielerTeamStruktur *sts );
-    // constant
-    Text *getPfad() const;
-    Text *zPfad() const;
+	// Konstruktor 
+	KartenLeser(int karteId, InformationServer* is);
+	// Destruktor
+	~KartenLeser();
+	// nicht constant
+	bool ladeSpielerTeamStruktur(SpielerTeamStruktur* sts);
+	// constant
+	Text* getPfad() const;
+	Text* zPfad() const;
 };
 
 #endif

InformationServer/main.cpp

@@ -7,55 +7,55 @@
 
 int main()
 {
-    struct rlimit core_limits;
-    core_limits.rlim_cur = core_limits.rlim_max = RLIM_INFINITY;
-    setrlimit( RLIMIT_CORE, &core_limits );
+	struct rlimit core_limits;
+	core_limits.rlim_cur = core_limits.rlim_max = RLIM_INFINITY;
+	setrlimit(RLIMIT_CORE, &core_limits);
 #ifdef DEBUG
-    //cd( "/test/information" );
+	//cd( "/test/information" );
 #endif
-    Framework::initFramework();
-    Zeit *z = getZeit();
-    Text *pfad = new Text( "../log/information/" );
-    pfad->append( z->getZeit( "y-m-d h-i-s.log" ) );
-    z->release();
-    DateiPfadErstellen( pfad->getText() );
-    std::ofstream file;
-    file.open( pfad->getText() );
-    std::streambuf *sbuf = std::cout.rdbuf();
-    std::cout.rdbuf( file.rdbuf() );
-    pfad->release();
+	Framework::initFramework();
+	Zeit* z = getZeit();
+	Text* pfad = new Text("../log/information/");
+	pfad->append(z->getZeit("y-m-d h-i-s.log"));
+	z->release();
+	DateiPfadErstellen(pfad->getText());
+	std::ofstream file;
+	file.open(pfad->getText());
+	std::streambuf* sbuf = std::cout.rdbuf();
+	std::cout.rdbuf(file.rdbuf());
+	pfad->release();
 
-    std::cout << "IS: Startet...\n";
-    std::cout << "IS: Lese init Datei ../data/isInit.ini ...\n";
-    InitDatei *dat = new InitDatei( "../data/isInit.ini" );
-    if( !dat->laden() )
-    {
-        std::cout << "IS: error: Datei konnte nicht gelesen werden. Das Programm wird geschlossen.\n";
-        dat->release();
-        exit( 1 );
-    }
-    const char *wichtig[] = { "ServerId", "DBBenutzer", "DBPasswort", "DBName", "DBIP", "DBPort", "Aktiv", "SSLCert", "SSLKey", "SSLPasswort" };
-    for( const char *w : wichtig )
-    {
-        if( !dat->wertExistiert( w ) )
-        {
-            std::cout << "IS: error: Der Wert '" << w << "' wurde nicht gefunden. Das Programm wird geschlossen.\n";
-            dat->release();
-            exit( 1 );
-        }
-    }
+	std::cout << "IS: Startet...\n";
+	std::cout << "IS: Lese init Datei ../data/isInit.ini ...\n";
+	InitDatei* dat = new InitDatei("../data/isInit.ini");
+	if (!dat->laden())
+	{
+		std::cout << "IS: error: Datei konnte nicht gelesen werden. Das Programm wird geschlossen.\n";
+		dat->release();
+		exit(1);
+	}
+	const char* wichtig[] = { "ServerId", "DBBenutzer", "DBPasswort", "DBName", "DBIP", "DBPort", "Aktiv", "SSLCert", "SSLKey", "SSLPasswort" };
+	for (const char* w : wichtig)
+	{
+		if (!dat->wertExistiert(w))
+		{
+			std::cout << "IS: error: Der Wert '" << w << "' wurde nicht gefunden. Das Programm wird geschlossen.\n";
+			dat->release();
+			exit(1);
+		}
+	}
 
-    InformationServer *iServer = new InformationServer( dat );
+	InformationServer* iServer = new InformationServer(dat);
 
-    std::cout << "IS: Der Admin Server läuft. Startforgang beendet.\n";
-    iServer->runn();
+	std::cout << "IS: Der Admin Server läuft. Startforgang beendet.\n";
+	iServer->runn();
 
-    iServer->ende();
-    iServer->release();
-    dat->release();
-    std::cout << "IS: Der Server ist heruntergefahren.\n";
-    file.close();
-    std::cout.rdbuf( sbuf );
-    Framework::releaseFramework();
-    return 0;
+	iServer->ende();
+	iServer->release();
+	dat->release();
+	std::cout << "IS: Der Server ist heruntergefahren.\n";
+	file.close();
+	std::cout.rdbuf(sbuf);
+	Framework::releaseFramework();
+	return 0;
 }