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, const char* ip, const 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
const char* RegisterClient::getLetzterFehler() const
{
	return err;
}