KSGNetwork/KSGNetwork/ShopClient.cpp

#include "ShopClient.h"
#include <Klient.h>
#include "Keys.h"
#include <Datei.h>
#include <Globals.h>

using namespace KSGClient;

// Inhalt der ShopClient Klasse

// Konstruktor
ShopClient::ShopClient( int klientId, unsigned short port, char *ip, char *key, unsigned char keyLen )
    : ReferenceCounter()
{
    this->ip = ip;
    this->port = port;
    cId = klientId;
    k = 0;
    this->key = new char[ keyLen ];
    memcpy( this->key, key, keyLen );
    this->keyLen = keyLen;
}

// Destruktor
ShopClient::~ShopClient()
{
    trenne( 1 );
    delete[] key;
}

// verbindet sich mit dem zugewiesenen Shop Server
//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
bool ShopClient::verbinde()
{
    cs.lock();
    if( k )
    {
        cs.unlock();
        return 1;
    }
    k = new Network::Klient();
    int l = 0;
    char *key;
    Keys::getServerKey( &key, l, Keys::SHOP, Keys::SENDEN );
    k->setSendeKey( key, l );
    delete[] key;
    Keys::getServerKey( &key, l, Keys::SHOP, Keys::EMPFANGEN );
    k->setEmpfangKey( key, l );
    delete[] key;
    if( k->verbinde( port, ip ) )
    {
        if( k->sendeEncrypted( "\1", 1 ) )
        {
            k->sendeEncrypted( (char *)&cId, 4 );
            char serverReturn = 0;
            k->getNachrichtEncrypted( &serverReturn, 1 );
            if( serverReturn == 3 )
            {
                char byte = 0;
                k->getNachrichtEncrypted( &byte, 1 );
                char *f = new char[ byte + 1 ];
                f[ byte ] = 0;
                k->getNachrichtEncrypted( f, byte );
                err = "error while identifying client Shop Server returned: ";
                err += f;
                delete[]f;
                trenne( 0 );
                cs.unlock();
                return 0;
            }
            k->setSendeKey( this->key, this->keyLen );
            k->setEmpfangKey( this->key, this->keyLen );
        }
        else
        {
            err = "network error while sending to Shop Server";
            k = (Network::Klient *)k->release();
            cs.unlock();
            return 0;
        }
    }
    else
    {
        err = "network error while connecting to Shop Server";
        k = (Network::Klient *)k->release();
        cs.unlock();
        return 0;
    }
    cs.unlock();
    return 1;
}

// Gibt eine Liste mit Spiel Ids zurück, mit Spielen, die einen Bestimten Text im Namen haben
//  suche: Der Text, der im Namen der Spiele vorkommen soll
//  Gibt bei misserfolg 0 zurück
Framework::Array< int > *ShopClient::suchSpiele( const char *suche )
{
    char län = (char)textLength( suche );
    char ret = 0;
    cs.lock();
    if( !k )
    {
        err = "Der Client ist nicht verbunden.";
        cs.unlock();
        return 0;
    }
    k->sendeEncrypted( "\5", 1 );
    k->getNachrichtEncrypted( &ret, 1 );
    if( ret == 1 )
    {
        k->sendeEncrypted( &län, 1 );
        if( län )
            k->sendeEncrypted( suche, län );
        k->getNachrichtEncrypted( &ret, 1 );
        if( ret == 1 )
        {
            int anz = 0;
            k->getNachrichtEncrypted( (char *)&anz, 4 );
            Array< int > *ret = new Array< int >();
            for( int i = 0; i < anz; i++ )
            {
                int w = 0;
                k->getNachrichtEncrypted( (char *)&w, 4 );
                ret->add( w );
            }
            cs.unlock();
            return ret;
        }
    }
    if( ret == 3 )
    {
        k->getNachrichtEncrypted( &län, 1 );
        char *fehler = new char[ län + 1 ];
        fehler[ län ] = 0;
        if( län )
            k->getNachrichtEncrypted( fehler, län );
        err = fehler;
        delete[] fehler;
        cs.unlock();
        return 0;
    }
    err = "Unbekannter Fehler";
    cs.unlock();
    return 0;
}

// läd Titelbild des Spieles herunter und speichert es unter data/tmp/shop/kazfen/spiele/{id}/titelbg.ltdb
//  id: Die Id des Spiels
//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
bool ShopClient::ladeSpielTitel( int id )
{
    char ret = 0;
    cs.lock();
    if( !k )
    {
        err = "Der Client ist nicht verbunden.";
        cs.unlock();
        return 0;
    }
    k->sendeEncrypted( "\6", 1 );
    k->getNachrichtEncrypted( &ret, 1 );
    if( ret == 1 )
    {
        k->sendeEncrypted( (char *)&id, 4 );
        k->getNachrichtEncrypted( &ret, 1 );
        if( ret == 1 )
        {
            Text *pf = new Text( "data/tmp/shop/kaufen/spiele/" );
            pf->append( id );
            pf->append( "/titelbg.ltdb" );
            Datei *dat = new Datei();
            dat->setDatei( pf );
            dat->erstellen();
            dat->open( Datei::Style::schreiben );
            __int64 gr = 0;
            k->getNachrichtEncrypted( (char *)&gr, 8 );
            char bytes[ 2048 ];
            while( gr > 0 )
            {
                int län = gr > 2048 ? 2048 : (int)gr;
                k->getNachricht( bytes, län );
                dat->schreibe( bytes, län );
                gr -= län;
            }
            dat->close();
            dat->release();
        }
        if( ret == 2 )
        { // Verweis auf anderen ShopServer
            char län = 0;
            k->getNachrichtEncrypted( (char *)&port, 4 );
            k->getNachrichtEncrypted( &län, 1 );
            delete[] ip;
            ip = new char[ län + 1 ];
            k->getNachrichtEncrypted( ip, län );
            ip[ län ] = 0;
            k->trenne();
            k = (Network::Klient *)k->release();
            if( !verbinde() )
            {
                err = "Fehler beim Verbinden mit zuständigen Shop Server.";
                cs.unlock();
                return 0;
            }
            cs.unlock();
            return ladeSpielTitel( id );
        }
    }
    if( ret == 3 )
    {
        k->getNachrichtEncrypted( &ret, 1 );
        char *fehler = new char[ ret + 1 ];
        fehler[ ret ] = 0;
        if( ret )
            k->getNachrichtEncrypted( fehler, ret );
        err = fehler;
        delete[] fehler;
        cs.unlock();
        return 0;
    }
    cs.unlock();
    return 1;
}

// läd Shop Seite des Spieles herunter und speichert es unter data/tmp/shop/kazfen/spiele/{id}/seite.ksgs
//  id: Die Id des Spiels
//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
bool ShopClient::ladeSpielSeite( int id )
{
    char ret = 0;
    cs.lock();
    if( !k )
    {
        err = "Der Client ist nicht verbunden.";
        cs.unlock();
        return 0;
    }
    k->sendeEncrypted( "\7", 1 );
    k->getNachrichtEncrypted( &ret, 1 );
    if( ret == 1 )
    {
        k->sendeEncrypted( (char *)&id, 4 );
        k->getNachrichtEncrypted( &ret, 1 );
        if( ret == 1 )
        {
            Text *pf = new Text( "data/tmp/shop/kaufen/spiele/" );
            pf->append( id );
            pf->append( "/" );
            int anz = 0;
            k->getNachrichtEncrypted( (char *)&anz, 4 );
            for( int i = 0; i < anz; i++ )
            {
                char län = 0;
                k->getNachrichtEncrypted( &län, 1 );
                char *name = new char[ län + 1 ];
                name[ län ] = 0;
                k->getNachrichtEncrypted( name, län );
                Text *pfad = new Text( pf->getText() );
                pfad->append( name );
                delete[] name;
                Datei *d = new Datei();
                d->setDatei( pfad );
                d->erstellen();
                d->open( Datei::Style::schreiben );
                __int64 gr = 0;
                k->getNachrichtEncrypted( (char *)&gr, 8 );
                char bytes[ 2048 ];
                while( gr > 0 )
                {
                    int län = gr > 2048 ? 2048 : (int)gr;
                    k->getNachricht( bytes, län );
                    d->schreibe( bytes, län );
                    gr -= län;
                }
                d->close();
                d->release();
            }
            pf->release();
        }
        if( ret == 2 )
        { // Verweis auf anderen ShopServer
            char län = 0;
            k->getNachrichtEncrypted( (char *)&port, 4 );
            k->getNachrichtEncrypted( &län, 1 );
            delete[] ip;
            ip = new char[ län + 1 ];
            k->getNachrichtEncrypted( ip, län );
            ip[ län ] = 0;
            k->trenne();
            k = (Network::Klient *)k->release();
            if( !verbinde() )
            {
                err = "Fehler beim Verbinden mit zuständigen Shop Server.";
                cs.unlock();
                return 0;
            }
            cs.unlock();
            return ladeSpielSeite( id );
        }
    }
    if( ret == 3 )
    {
        k->getNachrichtEncrypted( &ret, 1 );
        char *fehler = new char[ ret + 1 ];
        fehler[ ret ] = 0;
        if( ret )
            k->getNachrichtEncrypted( fehler, ret );
        err = fehler;
        delete[] fehler;
        cs.unlock();
        return 0;
    }
    cs.unlock();
    return 1;
}

// Gibt den Besitz Status eines Spiels zurück (0 = nicht im Besitz, 1 = Testversion, 2 = gekauft)
//  id: Die Id des Spiels
int ShopClient::getSpielBesitzStatus( int id )
{
    char ret = 0;
    cs.lock();
    if( !k )
    {
        err = "Der Client ist nicht verbunden.";
        cs.unlock();
        return 0;
    }
    k->sendeEncrypted( "\x8", 1 );
    k->getNachrichtEncrypted( &ret, 1 );
    if( ret == 1 )
    {
        k->sendeEncrypted( (char *)&id, 4 );
        int ret = 0;
        k->getNachrichtEncrypted( (char *)&ret, 4 );
        cs.unlock();
        return ret;
    }
    if( ret == 3 )
    {
        k->getNachrichtEncrypted( &ret, 1 );
        char *fehler = new char[ ret + 1 ];
        fehler[ ret ] = 0;
        if( ret )
            k->getNachrichtEncrypted( fehler, ret );
        err = fehler;
        delete[] fehler;
        cs.unlock();
        return 0;
    }
    err = "Unbekannter Fehler";
    cs.unlock();
    return 0;
}

// gibt die Anzahl der verbleibenden Spiele der Testversion zurück
//  id: Die Id des Spiels
int ShopClient::getSpielTestversion( int id )
{
    char ret = 0;
    cs.lock();
    if( !k )
    {
        err = "Der Client ist nicht verbunden.";
        cs.unlock();
        return 0;
    }
    k->sendeEncrypted( "\x9", 1 );
    k->getNachrichtEncrypted( &ret, 1 );
    if( ret == 1 )
    {
        k->sendeEncrypted( (char *)&id, 4 );
        int ret = 0;
        k->getNachrichtEncrypted( (char *)&ret, 4 );
        cs.unlock();
        return ret;
    }
    if( ret == 3 )
    {
        k->getNachrichtEncrypted( &ret, 1 );
        char *fehler = new char[ ret + 1 ];
        fehler[ ret ] = 0;
        if( ret )
            k->getNachrichtEncrypted( fehler, ret );
        err = fehler;
        delete[] fehler;
        cs.unlock();
        return 0;
    }
    err = "Unbekannter Fehler";
    cs.unlock();
    return 0;
}

// Gibt den Erwerbbarkeits Status eines Spiels zurück (0 = nichts, 1 = nur Testversion, 2 = nur Vollversion, 3 = beides)
//  id: Die Id des Spiels
int ShopClient::istSpielErwerbbar( int id )
{
    char ret = 0;
    cs.lock();
    if( !k )
    {
        err = "Der Client ist nicht verbunden.";
        cs.unlock();
        return 0;
    }
    k->sendeEncrypted( "\xA", 1 );
    k->getNachrichtEncrypted( &ret, 1 );
    if( ret == 1 )
    {
        k->sendeEncrypted( (char *)&id, 4 );
        int ret = 0;
        k->getNachrichtEncrypted( (char *)&ret, 4 );
        cs.unlock();
        return ret;
    }
    if( ret == 3 )
    {
        k->getNachrichtEncrypted( &ret, 1 );
        char *fehler = new char[ ret + 1 ];
        fehler[ ret ] = 0;
        if( ret )
            k->getNachrichtEncrypted( fehler, ret );
        err = fehler;
        delete[] fehler;
        cs.unlock();
        return 0;
    }
    err = "Unbekannter Fehler";
    cs.unlock();
    return 0;
}

// Gibt den Preis eines Spiels in Kupfer zurück
//  id: Die Id des Spiels
//  testVersion: 1:=Es wird der Preis der Testversion zurückgegeben, 0:=Es wird der Preis der Vollversion zurückgegeben
int ShopClient::getSpielPreis( int id, bool testVersion )
{
    char ret = 0;
    cs.lock();
    if( !k )
    {
        err = "Der Client ist nicht verbunden.";
        cs.unlock();
        return 0;
    }
    k->sendeEncrypted( "\xB", 1 );
    k->getNachrichtEncrypted( &ret, 1 );
    if( ret == 1 )
    {
        k->sendeEncrypted( (char *)&id, 4 );
        k->sendeEncrypted( (char *)&testVersion, 1 );
        int ret = 0;
        k->getNachrichtEncrypted( (char *)&ret, 4 );
        cs.unlock();
        return ret;
    }
    if( ret == 3 )
    {
        k->getNachrichtEncrypted( &ret, 1 );
        char *fehler = new char[ ret + 1 ];
        fehler[ ret ] = 0;
        if( ret )
            k->getNachrichtEncrypted( fehler, ret );
        err = fehler;
        delete[] fehler;
        cs.unlock();
        return 0;
    }
    err = "Unbekannter Fehler";
    cs.unlock();
    return 0;
}

// Kauft ein Spiel
//  id: Die Id des Spiels
//  testVersion: 1:=Es wird die Testversion erworben, 0:=Es wird die Vollversion erworben
bool ShopClient::spielErwerben( int spielId, bool testVersion )
{
    char ret = 0;
    cs.lock();
    if( !k )
    {
        err = "Der Client ist nicht verbunden.";
        cs.unlock();
        return 0;
    }
    k->sendeEncrypted( "\xC", 1 );
    k->getNachrichtEncrypted( &ret, 1 );
    if( ret == 1 )
    {
        k->sendeEncrypted( (char *)&spielId, 4 );
        k->sendeEncrypted( (char *)&testVersion, 1 );
        k->getNachrichtEncrypted( &ret, 1 );
        if( ret == 1 )
        {
            cs.unlock();
            return 1;
        }
    }
    if( ret == 3 )
    {
        k->getNachrichtEncrypted( &ret, 1 );
        char *fehler = new char[ ret + 1 ];
        fehler[ ret ] = 0;
        if( ret )
            k->getNachrichtEncrypted( fehler, ret );
        err = fehler;
        delete[] fehler;
        cs.unlock();
        return 0;
    }
    err = "Unbekannter Fehler";
    cs.unlock();
    return 0;
}

// sucht nach Karten mit zu einem bestimmten Spiel
//  suche: Ein Text, der im Namen der Karte vorkommen soll
//  spielId: Die Id des Spiels
//  Gibt eine Liste Mit den Ids der gefundenen Karten zurück
Framework::Array< int > *ShopClient::suchKarten( const char *suche, int spielId )
{
    char län = (char)textLength( suche );
    char ret = 0;
    cs.lock();
    if( !k )
    {
        err = "Der Client ist nicht verbunden.";
        cs.unlock();
        return 0;
    }
    k->sendeEncrypted( "\xD", 1 );
    k->getNachrichtEncrypted( &ret, 1 );
    if( ret == 1 )
    {
        k->sendeEncrypted( (char *)&spielId, 4 );
        k->sendeEncrypted( &län, 1 );
        if( län )
            k->sendeEncrypted( suche, län );
        k->getNachrichtEncrypted( &ret, 1 );
        if( ret == 1 )
        {
            int anz = 0;
            k->getNachrichtEncrypted( (char *)&anz, 4 );
            Array< int > *ret = new Array< int >();
            for( int i = 0; i < anz; i++ )
            {
                int w = 0;
                k->getNachrichtEncrypted( (char *)&w, 4 );
                ret->add( w );
            }
            cs.unlock();
            return ret;
        }
    }
    if( ret == 3 )
    {
        k->getNachrichtEncrypted( &län, 1 );
        char *fehler = new char[ län + 1 ];
        fehler[ län ] = 0;
        if( län )
            k->getNachrichtEncrypted( fehler, län );
        err = fehler;
        delete[] fehler;
        cs.unlock();
        return 0;
    }
    err = "Unbekannter Fehler";
    cs.unlock();
    return 0;
}

// lädt das Titelbild der Karte herunter und speichert es unter data/tmp/shop/kaufen/karten/{id}/titelbg.ltdb
//  id: Die Id der Karte
//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
bool ShopClient::ladeKarteTitel( int id )
{
    char ret = 0;
    cs.lock();
    if( !k )
    {
        err = "Der Client ist nicht verbunden.";
        cs.unlock();
        return 0;
    }
    k->sendeEncrypted( "\xE", 1 );
    k->getNachrichtEncrypted( &ret, 1 );
    if( ret == 1 )
    {
        k->sendeEncrypted( (char *)&id, 4 );
        k->getNachrichtEncrypted( &ret, 1 );
        if( ret == 1 )
        {
            Text *pf = new Text( "data/tmp/shop/kaufen/karten/" );
            pf->append( id );
            pf->append( "/titelbg.ltdb" );
            Datei *dat = new Datei();
            dat->setDatei( pf );
            dat->erstellen();
            dat->open( Datei::Style::schreiben );
            __int64 gr = 0;
            k->getNachrichtEncrypted( (char *)&gr, 8 );
            char bytes[ 2048 ];
            while( gr > 0 )
            {
                int län = gr > 2048 ? 2048 : (int)gr;
                k->getNachricht( bytes, län );
                dat->schreibe( bytes, län );
                gr -= län;
            }
            dat->close();
            dat->release();
        }
        if( ret == 2 )
        { // Verweis auf anderen ShopServer
            char län = 0;
            k->getNachrichtEncrypted( (char *)&port, 4 );
            k->getNachrichtEncrypted( &län, 1 );
            delete[] ip;
            ip = new char[ län + 1 ];
            k->getNachrichtEncrypted( ip, län );
            ip[ län ] = 0;
            k->trenne();
            k = (Network::Klient *)k->release();
            if( !verbinde() )
            {
                err = "Fehler beim Verbinden mit zuständigen Shop Server.";
                cs.unlock();
                return 0;
            }
            cs.unlock();
            return ladeKarteTitel( id );
        }
    }
    if( ret == 3 )
    {
        k->getNachrichtEncrypted( &ret, 1 );
        char *fehler = new char[ ret + 1 ];
        fehler[ ret ] = 0;
        if( ret )
            k->getNachrichtEncrypted( fehler, ret );
        err = fehler;
        delete[] fehler;
        cs.unlock();
        return 0;
    }
    cs.unlock();
    return 1;
}

// lädt die Shop Seite der Karte herunter und speichert es unter data/tmp/shop/kaufen/karten/{id}/seite.ksgs
//  id: Die Id der Karte
//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
bool ShopClient::ladeKarteSeite( int id )
{
    char ret = 0;
    cs.lock();
    if( !k )
    {
        err = "Der Client ist nicht verbunden.";
        cs.unlock();
        return 0;
    }
    k->sendeEncrypted( "\xF", 1 );
    k->getNachrichtEncrypted( &ret, 1 );
    if( ret == 1 )
    {
        k->sendeEncrypted( (char *)&id, 4 );
        k->getNachrichtEncrypted( &ret, 1 );
        if( ret == 1 )
        {
            Text *pf = new Text( "data/tmp/shop/kaufen/karten/" );
            pf->append( id );
            pf->append( "/" );
            int anz = 0;
            k->getNachrichtEncrypted( (char *)&anz, 4 );
            for( int i = 0; i < anz; i++ )
            {
                char län = 0;
                k->getNachrichtEncrypted( &län, 1 );
                char *name = new char[ län + 1 ];
                name[ län ] = 0;
                k->getNachrichtEncrypted( name, län );
                Text *pfad = new Text( pf->getText() );
                pfad->append( name );
                delete[] name;
                Datei *d = new Datei();
                d->setDatei( pfad );
                d->erstellen();
                d->open( Datei::Style::schreiben );
                __int64 gr = 0;
                k->getNachrichtEncrypted( (char *)&gr, 8 );
                char bytes[ 2048 ];
                while( gr > 0 )
                {
                    int län = gr > 2048 ? 2048 : (int)gr;
                    k->getNachricht( bytes, län );
                    d->schreibe( bytes, län );
                    gr -= län;
                }
                d->close();
                d->release();
            }
            pf->release();
        }
        if( ret == 2 )
        { // Verweis auf anderen ShopServer
            char län = 0;
            k->getNachrichtEncrypted( (char *)&port, 4 );
            k->getNachrichtEncrypted( &län, 1 );
            delete[] ip;
            ip = new char[ län + 1 ];
            k->getNachrichtEncrypted( ip, län );
            ip[ län ] = 0;
            k->trenne();
            k = (Network::Klient *)k->release();
            if( !verbinde() )
            {
                err = "Fehler beim Verbinden mit zuständigen Shop Server.";
                cs.unlock();
                return 0;
            }
            cs.unlock();
            return ladeKarteSeite( id );
        }
    }
    if( ret == 3 )
    {
        k->getNachrichtEncrypted( &ret, 1 );
        char *fehler = new char[ ret + 1 ];
        fehler[ ret ] = 0;
        if( ret )
            k->getNachrichtEncrypted( fehler, ret );
        err = fehler;
        delete[] fehler;
        cs.unlock();
        return 0;
    }
    cs.unlock();
    return 1;
}

// Gibt den Besitz Status einer Karte zurück (0 = nicht im Besitz, 1 = Testversion, 2 = gekauft)
//  id: Die Id der Karte
int ShopClient::getKarteBesitzStatus( int id )
{
    char ret = 0;
    cs.lock();
    if( !k )
    {
        err = "Der Client ist nicht verbunden.";
        cs.unlock();
        return 0;
    }
    k->sendeEncrypted( "\x10", 1 );
    k->getNachrichtEncrypted( &ret, 1 );
    if( ret == 1 )
    {
        k->sendeEncrypted( (char *)&id, 4 );
        int ret = 0;
        k->getNachrichtEncrypted( (char *)&ret, 4 );
        cs.unlock();
        return ret;
    }
    if( ret == 3 )
    {
        k->getNachrichtEncrypted( &ret, 1 );
        char *fehler = new char[ ret + 1 ];
        fehler[ ret ] = 0;
        if( ret )
            k->getNachrichtEncrypted( fehler, ret );
        err = fehler;
        delete[] fehler;
        cs.unlock();
        return 0;
    }
    err = "Unbekannter Fehler";
    cs.unlock();
    return 0;
}

// gibt die Anzahl der verbleibenden Spiele der Testversion zurück
//  id: Die Id der Karte
int ShopClient::getKarteTestversion( int id )
{
    char ret = 0;
    cs.lock();
    if( !k )
    {
        err = "Der Client ist nicht verbunden.";
        cs.unlock();
        return 0;
    }
    k->sendeEncrypted( "\x11", 1 );
    k->getNachrichtEncrypted( &ret, 1 );
    if( ret == 1 )
    {
        k->sendeEncrypted( (char *)&id, 4 );
        int ret = 0;
        k->getNachrichtEncrypted( (char *)&ret, 4 );
        cs.unlock();
        return ret;
    }
    if( ret == 3 )
    {
        k->getNachrichtEncrypted( &ret, 1 );
        char *fehler = new char[ ret + 1 ];
        fehler[ ret ] = 0;
        if( ret )
            k->getNachrichtEncrypted( fehler, ret );
        err = fehler;
        delete[] fehler;
        cs.unlock();
        return 0;
    }
    err = "Unbekannter Fehler";
    cs.unlock();
    return 0;
}

// Gibt den Erwerbbarkeits Status einer Karte zurück (0 = nichts, 1 = nur Testversion, 2 = nur Vollversion, 3 = beides)
//  id: Die Id der Karte
int ShopClient::istKarteErwerbbar( int id )
{
    char ret = 0;
    cs.lock();
    if( !k )
    {
        err = "Der Client ist nicht verbunden.";
        cs.unlock();
        return 0;
    }
    k->sendeEncrypted( "\x12", 1 );
    k->getNachrichtEncrypted( &ret, 1 );
    if( ret == 1 )
    {
        k->sendeEncrypted( (char *)&id, 4 );
        int ret = 0;
        k->getNachrichtEncrypted( (char *)&ret, 4 );
        cs.unlock();
        return ret;
    }
    if( ret == 3 )
    {
        k->getNachrichtEncrypted( &ret, 1 );
        char *fehler = new char[ ret + 1 ];
        fehler[ ret ] = 0;
        if( ret )
            k->getNachrichtEncrypted( fehler, ret );
        err = fehler;
        delete[] fehler;
        cs.unlock();
        return 0;
    }
    err = "Unbekannter Fehler";
    cs.unlock();
    return 0;
}

// Gibt den Preis einer Karte in Kupfer zurück
//  id: Die Id der Karte
//  testVersion: 1:=Es wird der Preis der Testversion zurückgegeben, 0:=Es wird der Preis der Vollversion zurückgegeben
int ShopClient::getKartePreis( int id, bool testVersion )
{
    char ret = 0;
    cs.lock();
    if( !k )
    {
        err = "Der Client ist nicht verbunden.";
        cs.unlock();
        return 0;
    }
    k->sendeEncrypted( "\x13", 1 );
    k->getNachrichtEncrypted( &ret, 1 );
    if( ret == 1 )
    {
        k->sendeEncrypted( (char *)&id, 4 );
        k->sendeEncrypted( (char *)&testVersion, 1 );
        int ret = 0;
        k->getNachrichtEncrypted( (char *)&ret, 4 );
        cs.unlock();
        return ret;
    }
    if( ret == 3 )
    {
        k->getNachrichtEncrypted( &ret, 1 );
        char *fehler = new char[ ret + 1 ];
        fehler[ ret ] = 0;
        if( ret )
            k->getNachrichtEncrypted( fehler, ret );
        err = fehler;
        delete[] fehler;
        cs.unlock();
        return 0;
    }
    err = "Unbekannter Fehler";
    cs.unlock();
    return 0;
}

// Kauft eine Karte
//  id: Die Id der Karte
//  testVersion: 1:=Es wird die Testversion erworben, 0:=Es wird die Vollversion erworben
bool ShopClient::karteErwerben( int karteId, bool testVersion )
{
    char ret = 0;
    cs.lock();
    if( !k )
    {
        err = "Der Client ist nicht verbunden.";
        cs.unlock();
        return 0;
    }
    k->sendeEncrypted( "\x14", 1 );
    k->getNachrichtEncrypted( &ret, 1 );
    if( ret == 1 )
    {
        k->sendeEncrypted( (char *)&karteId, 4 );
        k->sendeEncrypted( (char *)&testVersion, 1 );
        k->getNachrichtEncrypted( &ret, 1 );
        if( ret == 1 )
        {
            cs.unlock();
            return 1;
        }
    }
    if( ret == 3 )
    {
        k->getNachrichtEncrypted( &ret, 1 );
        char *fehler = new char[ ret + 1 ];
        fehler[ ret ] = 0;
        if( ret )
            k->getNachrichtEncrypted( fehler, ret );
        err = fehler;
        delete[] fehler;
        cs.unlock();
        return 0;
    }
    err = "Unbekannter Fehler";
    cs.unlock();
    return 0;
}

// Erhält die Verbindung aufrecht
//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
//  Sollte während einer bestehenden Verbindung etwa einmal alle 60 Sekunden aufgerufen werden, da sonst der Router die Verbindung automatisch trennt
bool ShopClient::keepAlive()
{
    if( !k )
        return 0;
    char res = 0;
    if( !cs.tryLock() )
        return 1;
    Framework::logLine( (char *)"Verbindungstest zum Shop Server..." );
    bool ok = k->sendeEncrypted( "\x15", 1 );
    ok &= k->getNachrichtEncrypted( &res, 1 );
    cs.unlock();
    if( res != 1 || !ok )
    {
        Framework::logLine( (char *)"Verbindungsabbruch." );
        trenne( 0 );
    }
    else
        Framework::logLine( (char *)"Verbindung besteht." );
    return res == 1;
}

// Trennt die Verbindung zum Server
//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
//  Sollte erst nach einem erfolgreichen Aufruf von verbinde aufgerufen werden
bool ShopClient::trenne( bool abmelden )
{
    cs.lock();
    verbinde();
    if( !k )
    {
        cs.unlock();
        return 1;
    }
    if( abmelden )
    {
        k->sendeEncrypted( "\4", 1 );
        char ret = 0;
        k->getNachrichtEncrypted( &ret, 1 );
        if( ret == 3 )
        { // error
            k->getNachrichtEncrypted( &ret, 1 );
            char *msg = new char[ ret + 1 ];
            msg[ ret ] = 0;
            if( ret )
                k->getNachrichtEncrypted( msg, ret );
            err = "error while unregister Client Login Server returned: ";
            err += msg;
            delete[] msg;
        }
    }
    k->sendeEncrypted( "\3", 1 );
    char ret = 0;
    k->getNachrichtEncrypted( &ret, 1 );
    if( ret == 3 )
    { // error
        k->getNachrichtEncrypted( &ret, 1 );
        char *msg = new char[ ret + 1 ];
        msg[ ret ] = 0;
        if( ret )
            k->getNachrichtEncrypted( msg, ret );
        err = "error while trenne Login Server returned: ";
        err += msg;
        delete[] msg;
    }
    k->trenne();
    k = (Network::Klient *)k->release();
    cs.unlock();
    return 1;
}

// Gibt 1 zurück, falls der Client verbunden ist, 0 sonst
bool ShopClient::istVerbunden() const
{
    return k != 0;
}

// gibt den Letzten Fehlertext zuück
//  sollte erst aufgerufen werden, nachdem eine andere aufgerufene Methode fehlgeschlagen ist
char *ShopClient::getLetzterFehler() const
{
    return err;
}