KSGNetwork/KSGNetwork/ErhaltungClient.cpp

#include "ErhaltungClient.h"
#include <Klient.h>
#include "Keys.h"

using namespace KSGClient;

// Inhalt der ErhaltungClient Klasse

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

// Destruktor
ErhaltungClient::~ErhaltungClient()
{
    if( k )
    {
        abmelden();
        trenne();
    }
    warteAufThread( 10000 );
    ende();
    if( k )
        k->release();
    delete[] key;
}

// DBeantwortet Ping - Anfragen des Servers. Falls diese 60 Sekunden lang unbeantwortet bleiben, wird der Client vom Serversystem abgemeldet
void ErhaltungClient::thread()
{
    while( 1 )
    {
        char n = 0;
        k->getNachrichtEncrypted( &n, 1 );
        if( n != 1 )
        {
            Sleep( 250 );
            continue;
        }
        if( trenn )
        {
            if( abmel )
            {
                k->sendeEncrypted( "\1", 1 );
                k->getNachrichtEncrypted( &n, 1 );
            }
            k->trenne();
            run = 0;
            return;
        }
        else
            k->sendeEncrypted( "\0", 1 );
    }
}

// verbindet ich mit dem Erhaltung Server
//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
bool ErhaltungClient::verbinde()
{
    cs.lock();
    if( k )
    {
        cs.unlock();
        return 1;
    }
    k = new Network::Klient();
    int l = 0;
    char *key;
    Keys::getServerKey( &key, l, Keys::ERHALTUNG, Keys::SENDEN );
    k->setSendeKey( key, l );
    delete[] key;
    Keys::getServerKey( &key, l, Keys::ERHALTUNG, Keys::EMPFANGEN );
    k->setEmpfangKey( key, l );
    delete[] key;
    if( k->verbinde( port, ip ) )
    {
        k->sende( "\0", 1 ); // Verschlüsselung Aktivieren
        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 identifyin client Erhaltung Server returned: ";
                err += f;
                delete[]f;
                k->sendeEncrypted( "\3", 1 );
                k->getNachrichtEncrypted( &serverReturn, 1 );
                k->trenne();
                k = k->release();
                cs.unlock();
                return 0;
            }
            k->setSendeKey( this->key, this->keyLen );
            k->setEmpfangKey( this->key, this->keyLen );
            start();
        }
        else
        {
            err = "network error while sending to Erhaltung Server";
            k = k->release();
            cs.unlock();
            return 0;
        }
    }
    else
    {
        err = "network error while connecting to Erhaltung Server";
        k = k->release();
        cs.unlock();
        return 0;
    }
    cs.unlock();
    return 1;
}

// Meldet sich beim Server ab und trennt die Verbindung
void ErhaltungClient::abmelden()
{
    abmel = 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 ErhaltungClient::trenne()
{
    trenn = 1;
    return 1;
}

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

// Erhöht den Reference Counter um 1 un gibt this zurück
Thread *ErhaltungClient::getThis()
{
    return Thread::getThis();
}

// Verringert den Reference Counter um 1 und gibt 0 zurück.
//  Falls der Reference Counter nach dem Aufruf auf 0 ist löscht sich das Objekt selbst 
Thread *ErhaltungClient::release()
{
    return Thread::release();
}