KSGNetwork/KSGNetwork/RegisterClient.cpp

#include "RegisterServer.h"
#include <Klient.h>
#include "Keys.h"
#include <Globals.h>


using namespace KSGClient;

// Inhalt der RegisterClient Klasse


// Konstruktor
RegisterClient::RegisterClient( 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
RegisterClient::~RegisterClient()
{
    trenne( 1 );
    delete[] key;
}

// verbindet ich mit dem Register Server
//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
bool RegisterClient::verbinde()
{
    cs.lock();
    if( k )
    {
        cs.unlock();
        return 1;
    }
    k = new Network::Klient();
    int l = 0;
    char *key;
    Keys::getServerKey( &key, l, Keys::REGISTER, Keys::SENDEN );
    k->setSendeKey( key, l );
    delete[] key;
    Keys::getServerKey( &key, l, Keys::REGISTER, 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 Register 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 Register Server";
            k = (Network::Klient *)k->release();
            cs.unlock();
            return 0;
        }
    }
    else
    {
        err = "network error while connecting to Patch Server";
        k = (Network::Klient *)k->release();
        cs.unlock();
        return 0;
    }
    cs.unlock();
    return 1;
}

// Sendet eine Anfrage auf Erstellung eines neuen Accounts. Ein neuer Account kann erst verwendet werden, wenn ein Link in der Bestätigungsemail angeklickt wurde.
//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
//  name: Der Login Name des Accounts
//  pass: Das Login Passwort des Accounts
//  geheim: Das Geheimnis des Accounts
//  eMail: Die EMail Adresse an die die bestätigungs EMail gesendet werden soll
//  jahr: Das Jahr des Geburtsdatums
//  monat: Der Monat des Geburtstages
//  tag: Der Tag des Geburtstages
bool RegisterClient::accountErstellen( const char *name, const char *pass, const char *geheim, const char *eMail, unsigned short jahr, char monat, char tag )
{
    cs.lock();
    if( !k )
    {
        err = "Der Client ist nicht verbunden.";
        cs.unlock();
        return 0;
    }
    k->sendeEncrypted( "\5", 1 );
    char serverReturn = 0;
    k->getNachrichtEncrypted( &serverReturn, 1 );
    if( serverReturn == 1 )
    {
        unsigned char län[ 4 ] = {
            (unsigned char)textLength( name ),
            (unsigned char)textLength( pass ),
            (unsigned char)textLength( geheim ),
            (unsigned char)textLength( eMail )
        };
        k->sendeEncrypted( (char *)län, 4 );
        k->sendeEncrypted( name, län[ 0 ] );
        k->sendeEncrypted( pass, län[ 1 ] );
        k->sendeEncrypted( geheim, län[ 2 ] );
        k->sendeEncrypted( eMail, län[ 3 ] );
        k->sendeEncrypted( (char *)&jahr, 2 );
        k->sendeEncrypted( &monat, 1 );
        k->sendeEncrypted( &tag, 1 );
        k->getNachrichtEncrypted( &serverReturn, 1 );
        if( serverReturn == 1 )
        {
            cs.unlock();
            return 1;
        }
    }
    if( serverReturn == 3 )
    {
        char byte = 0;
        k->getNachrichtEncrypted( &byte, 1 );
        char *fehler = new char[ byte + 1 ];
        fehler[ byte ] = 0;
        k->getNachrichtEncrypted( fehler, byte );
        err = fehler;
        delete[]fehler;
        cs.unlock();
        return 0;
    }
    err = "Unbekannter Fehler";
    cs.unlock();
    return 0;
}

// Sendet eine Anfrage auf Löschung eines neuen Accounts. Ein neuer Account kann erst gelöscht werden, wenn ein Link in der Bestätigungsemail angeklickt wurde.
//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
//  name: Der Login Name des Accounts
//  pass: Das Login Passwort des Accounts
//  geheim: Das Geheimnis des Accounts
bool RegisterClient::accountLöschen( const char *name, const char *pass, const char *geheim )
{
    cs.lock();
    if( !k )
    {
        err = "Der Client ist nicht verbunden.";
        cs.unlock();
        return 0;
    }
    k->sendeEncrypted( "\6", 1 );
    char serverReturn = 0;
    k->getNachrichtEncrypted( &serverReturn, 1 );
    if( serverReturn == 1 )
    {
        unsigned char län[ 3 ] = {
            (unsigned char)textLength( name ),
            (unsigned char)textLength( pass ),
            (unsigned char)textLength( geheim )
        };
        k->sendeEncrypted( (char *)län, 3 );
        k->sendeEncrypted( name, län[ 0 ] );
        k->sendeEncrypted( pass, län[ 1 ] );
        k->sendeEncrypted( geheim, län[ 2 ] );
        k->getNachrichtEncrypted( &serverReturn, 1 );
        if( serverReturn == 1 )
        {
            cs.unlock();
            return 1;
        }
    }
    if( serverReturn == 3 )
    {
        char byte = 0;
        k->getNachrichtEncrypted( &byte, 1 );
        char *fehler = new char[ byte + 1 ];
        fehler[ byte ] = 0;
        k->getNachrichtEncrypted( fehler, byte );
        err = fehler;
        delete[]fehler;
        cs.unlock();
        return 0;
    }
    err = "Unbekannter Fehler";
    cs.unlock();
    return 0;
}

// Ändert das Passwort eines Accounts
//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
//  name: Der Login Name des Accounts
//  pass: Das Login Passwort des Accounts
//  geheim: Das Geheimnis des Accounts
//  nPass: Das neue Passwort des Accounts
bool RegisterClient::passwortÄndern( const char *name, const char *pass, const char *geheim, const char *nPass )
{
    cs.lock();
    if( !k )
    {
        err = "Der Client ist nicht verbunden.";
        cs.unlock();
        return 0;
    }
    k->sendeEncrypted( "\7", 1 );
    char serverReturn = 0;
    k->getNachrichtEncrypted( &serverReturn, 1 );
    if( serverReturn == 1 )
    {
        unsigned char län[ 4 ] = {
            (unsigned char)textLength( name ),
            (unsigned char)textLength( pass ),
            (unsigned char)textLength( nPass ),
            (unsigned char)textLength( geheim )
        };
        k->sendeEncrypted( (char *)län, 4 );
        k->sendeEncrypted( name, län[ 0 ] );
        k->sendeEncrypted( pass, län[ 1 ] );
        k->sendeEncrypted( nPass, län[ 2 ] );
        k->sendeEncrypted( geheim, län[ 3 ] );
        k->getNachrichtEncrypted( &serverReturn, 1 );
        if( serverReturn == 1 )
        {
            cs.unlock();
            return 1;
        }
    }
    if( serverReturn == 3 )
    {
        char byte = 0;
        k->getNachrichtEncrypted( &byte, 1 );
        char *fehler = new char[ byte + 1 ];
        fehler[ byte ] = 0;
        k->getNachrichtEncrypted( fehler, byte );
        err = fehler;
        delete[]fehler;
        cs.unlock();
        return 0;
    }
    err = "Unbekannter Fehler";
    cs.unlock();
    return 0;
}

// Ändert die EMail Adresse eines Accounts
//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
//  name: Der Login Name des Accounts
//  pass: Das Login Passwort des Accounts
//  geheim: Das Geheimnis des Accounts
//  nEMail: Die neue EMail Adresse
bool RegisterClient::eMailÄndern( const char *name, const char *pass, const char *geheim, const char *nEMail )
{
    cs.lock();
    if( !k )
    {
        err = "Der Client ist nicht verbunden.";
        cs.unlock();
        return 0;
    }
    char byte = 8;
    k->sendeEncrypted( &byte, 1 );
    char serverReturn = 0;
    k->getNachrichtEncrypted( &serverReturn, 1 );
    if( serverReturn == 1 )
    {
        unsigned char län[ 4 ] = {
            (unsigned char)textLength( name ),
            (unsigned char)textLength( pass ),
            (unsigned char)textLength( geheim ),
            (unsigned char)textLength( nEMail )
        };
        k->sendeEncrypted( (char *)län, 4 );
        k->sendeEncrypted( name, län[ 0 ] );
        k->sendeEncrypted( pass, län[ 1 ] );
        k->sendeEncrypted( geheim, län[ 2 ] );
        k->sendeEncrypted( nEMail, län[ 3 ] );
        k->getNachrichtEncrypted( &serverReturn, 1 );
        if( serverReturn == 1 )
        {
            cs.unlock();
            return 1;
        }
    }
    if( serverReturn == 3 )
    {
        char byte = 0;
        k->getNachrichtEncrypted( &byte, 1 );
        char *fehler = new char[ byte + 1 ];
        fehler[ byte ] = 0;
        k->getNachrichtEncrypted( fehler, byte );
        err = fehler;
        delete[]fehler;
        cs.unlock();
        return 0;
    }
    err = "Unbekannter Fehler";
    cs.unlock();
    return 0;
}

// Ändert das Geheimnis eines Accounts
//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
//  name: Der Login Name des Accounts
//  pass: Das Login Passwort des Accounts
//  geheim: Das Geheimnis des Accounts
//  nGeheim: Das neue Geheimnis
bool RegisterClient::geheimnisÄndern( const char *name, const char *pass, const char *geheim, const char *nGeheim )
{
    cs.lock();
    if( !k )
    {
        err = "Der Client ist nicht verbunden.";
        cs.unlock();
        return 0;
    }
    char byte = 9;
    k->sendeEncrypted( &byte, 1 );
    char serverReturn = 0;
    k->getNachrichtEncrypted( &serverReturn, 1 );
    if( serverReturn == 1 )
    {
        unsigned char län[ 4 ] = {
            (unsigned char)textLength( name ),
            (unsigned char)textLength( pass ),
            (unsigned char)textLength( geheim ),
            (unsigned char)textLength( nGeheim )
        };
        k->sendeEncrypted( (char *)län, 4 );
        k->sendeEncrypted( name, län[ 0 ] );
        k->sendeEncrypted( pass, län[ 1 ] );
        k->sendeEncrypted( geheim, län[ 2 ] );
        k->sendeEncrypted( nGeheim, län[ 3 ] );
        k->getNachrichtEncrypted( &serverReturn, 1 );
        if( serverReturn == 1 )
        {
            cs.unlock();
            return 1;
        }
    }
    if( serverReturn == 3 )
    {
        char byte = 0;
        k->getNachrichtEncrypted( &byte, 1 );
        char *fehler = new char[ byte + 1 ];
        fehler[ byte ] = 0;
        k->getNachrichtEncrypted( fehler, byte );
        err = fehler;
        delete[]fehler;
        cs.unlock();
        return 0;
    }
    err = "Unbekannter Fehler";
    cs.unlock();
    return 0;
}

// Sendet eine Anfrage auf Name Vergessen. Der Name wird an die angegebene EMail Adresse gesendet
//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
//  pass: Das Login Passwort des Accounts
//  geheim: Das Geheimnis des Accounts
bool RegisterClient::nameVergessen( const char *pass, const char *geheim )
{
    cs.lock();
    if( !k )
    {
        err = "Der Client ist nicht verbunden.";
        cs.unlock();
        return 0;
    }
    char byte = 0xA;
    k->sendeEncrypted( &byte, 1 );
    char serverReturn = 0;
    k->getNachrichtEncrypted( &serverReturn, 1 );
    if( serverReturn == 1 )
    {
        unsigned char län[ 2 ] = {
            (unsigned char)textLength( pass ),
            (unsigned char)textLength( geheim )
        };
        k->sendeEncrypted( (char *)län, 2 );
        k->sendeEncrypted( pass, län[ 0 ] );
        k->sendeEncrypted( geheim, län[ 1 ] );
        k->getNachrichtEncrypted( &serverReturn, 1 );
        if( serverReturn == 1 )
        {
            cs.unlock();
            return 1;
        }
    }
    if( serverReturn == 3 )
    {
        char byte = 0;
        k->getNachrichtEncrypted( &byte, 1 );
        char *fehler = new char[ byte + 1 ];
        fehler[ byte ] = 0;
        k->getNachrichtEncrypted( fehler, byte );
        err = fehler;
        delete[]fehler;
        cs.unlock();
        return 0;
    }
    err = "Unbekannter Fehler";
    cs.unlock();
    return 0;
}

// Sendet eine Anfrage auf Passwort Vergessen. Es wird ein Link an die angegebene Email Adresse gesendet, über den ein neues Passwort vergeben werden kann
//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
//  name: Der Login Name des Accounts
//  geheim: Das Geheimnis des Accounts
bool RegisterClient::passwortVergessen( const char *name, const char *geheim )
{
    cs.lock();
    if( !k )
    {
        err = "Der Client ist nicht verbunden.";
        cs.unlock();
        return 0;
    }
    char byte = 0xB;
    k->sendeEncrypted( &byte, 1 );
    char serverReturn = 0;
    k->getNachrichtEncrypted( &serverReturn, 1 );
    if( serverReturn == 1 )
    {
        unsigned char län[ 2 ] = {
            (unsigned char)textLength( name ),
            (unsigned char)textLength( geheim )
        };
        k->sendeEncrypted( (char *)län, 2 );
        k->sendeEncrypted( name, län[ 0 ] );
        k->sendeEncrypted( geheim, län[ 1 ] );
        k->getNachrichtEncrypted( &serverReturn, 1 );
        if( serverReturn == 1 )
        {
            cs.unlock();
            return 1;
        }
    }
    if( serverReturn == 3 )
    {
        char byte = 0;
        k->getNachrichtEncrypted( &byte, 1 );
        char *fehler = new char[ byte + 1 ];
        fehler[ byte ] = 0;
        k->getNachrichtEncrypted( fehler, byte );
        err = fehler;
        delete[]fehler;
        cs.unlock();
        return 0;
    }
    err = "Unbekannter Fehler";
    cs.unlock();
    return 0;
}

// Sendet eine Anfrage auf Geheimnis Vergessen. Das Geheimnis wird an die angegebene EMail Adresse gesendet
//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
//  name: Der Login Name des Accounts
//  pass: Das Login Passwort des Accounts
bool RegisterClient::geheimnisVergessen( const char *name, const char *pass )
{
    cs.lock();
    if( !k )
    {
        err = "Der Client ist nicht verbunden.";
        cs.unlock();
        return 0;
    }
    char byte = 0xC;
    k->sendeEncrypted( &byte, 1 );
    char serverReturn = 0;
    k->getNachrichtEncrypted( &serverReturn, 1 );
    if( serverReturn == 1 )
    {
        unsigned char län[ 2 ] = {
            (unsigned char)textLength( name ),
            (unsigned char)textLength( pass )
        };
        k->sendeEncrypted( (char *)län, 2 );
        k->sendeEncrypted( name, län[ 0 ] );
        k->sendeEncrypted( pass, län[ 1 ] );
        k->getNachrichtEncrypted( &serverReturn, 1 );
        if( serverReturn == 1 )
        {
            cs.unlock();
            return 1;
        }
    }
    if( serverReturn == 3 )
    {
        char byte = 0;
        k->getNachrichtEncrypted( &byte, 1 );
        char *fehler = new char[ byte + 1 ];
        fehler[ byte ] = 0;
        k->getNachrichtEncrypted( fehler, byte );
        err = fehler;
        delete[]fehler;
        cs.unlock();
        return 0;
    }
    err = "Unbekannter Fehler";
    cs.unlock();
    return 0;
}

// Sendet eine Anfrage auf EMail Vergessen. Die EMail Adresse wird direkt vom Server zurückgegeben
//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
//  name: Der Login Name des Accounts
//  pass: Das Login Passwort des Accounts
//  geheim: Das Geheimnis des Accounts
//  eMail: Ein Zeiger auf eine Zeichenkette. Diese wird bei einem Erfolgreichen Aufruf auf die EMail Adresse gesetzt und muss manuell mit delete[] gelöscht werden
bool RegisterClient::eMailVergessen( const char *name, const char *pass, const char *geheim, char **eMail )
{
    cs.lock();
    if( !k )
    {
        err = "Der Client ist nicht verbunden.";
        cs.unlock();
        return 0;
    }
    char byte2 = 0xD;
    k->sendeEncrypted( &byte2, 1 );
    char serverReturn = 0;
    k->getNachrichtEncrypted( &serverReturn, 1 );
    if( serverReturn == 1 )
    {
        unsigned char län[ 3 ] = {
            (unsigned char)textLength( name ),
            (unsigned char)textLength( pass ),
            (unsigned char)textLength( geheim )
        };
        k->sendeEncrypted( (char *)län, 3 );
        k->sendeEncrypted( name, län[ 0 ] );
        k->sendeEncrypted( pass, län[ 1 ] );
        k->sendeEncrypted( geheim, län[ 2 ] );
        k->getNachrichtEncrypted( &serverReturn, 1 );
        if( serverReturn == 1 )
        {
            unsigned char len = 0;
            k->getNachrichtEncrypted( (char *)&len, 1 );
            char *mail = new char[ len + 1 ];
            mail[ len ] = 0;
            k->getNachrichtEncrypted( mail, len );
            *eMail = mail;
            cs.unlock();
            return 1;
        }
    }
    if( serverReturn == 3 )
    {
        char byte = 0;
        k->getNachrichtEncrypted( &byte, 1 );
        char *fehler = new char[ byte + 1 ];
        fehler[ byte ] = 0;
        k->getNachrichtEncrypted( fehler, byte );
        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 RegisterClient::keepAlive()
{
    if( !k )
        return 0;
    char res = 0;
    if( !cs.tryLock() )
        return 1;
    Framework::logLine( (char *)"Verbindungstest zum Register Server..." );
    bool ok = k->sendeEncrypted( "\xF", 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 RegisterClient::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 Register 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 Register 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 RegisterClient::istVerbunden() const
{
    return k != 0;
}

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