KSGNetwork/KSGNetwork/PatchClient.cpp

#include "PatchClient.h"
#include <Klient.h>
#include <KSGTDatei.h>
#include "Keys.h"
#include <Datei.h>
#include <Zeit.h>
#include <Fortschritt.h>

using namespace KSGClient;

// Inhalt der PatchClient Klasse

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

// verbindet ich mit dem Patch Server
//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
bool PatchClient::verbinde()
{
	cs.lock();
	if (k)
	{
		cs.unlock();
		return 1;
	}
	k = new Network::Klient();
	int l = 0;
	char* key;
	Keys::getServerKey(&key, l, Keys::PATCH, Keys::SENDEN);
	k->setSendeKey(key, l);
	delete[] key;
	Keys::getServerKey(&key, l, Keys::PATCH, 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);
#ifdef _X64
			k->sendeEncrypted("\2", 1); // 64 Bit Client
#else
			k->sendeEncrypted("\1", 1); // 32 Bit Client
#endif
			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 Patch 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 Patch 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;
}

// Gibt eine Tabelle von Dateigruppen zurück.
//  Gibt bei misserfolg 0 zurück
Framework::KSGTDatei* PatchClient::getDateiGruppenListe()
{
	cs.lock();
	if (!k)
	{
		err = "Der Client ist nicht verbunden.";
		cs.unlock();
		return 0;
	}
	k->sendeEncrypted("\xC", 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 = msg;
		delete[] msg;
		cs.unlock();
		return 0;
	}
	Framework::KSGTDatei* dgtb = new Framework::KSGTDatei();
	int id = 0;
	k->getNachrichtEncrypted((char*)&id, 4);
	while (id)
	{
		RCArray< Text >* zeile = new RCArray< Text >();
		Text* idT = new Text();
		idT->append(id);
		zeile->set(idT, 0);
		int län = 0;
		k->getNachrichtEncrypted((char*)&län, 4);
		char* pfad = new char[län + 1];
		pfad[län] = 0;
		if (län)
			k->getNachrichtEncrypted(pfad, län);
		zeile->set(new Text(pfad), 1);
		delete[] pfad;
		int vs = 0;
		k->getNachrichtEncrypted((char*)&vs, 4);
		Text* vsT = new Text();
		vsT->append(vs);
		zeile->set(vsT, 2);
		dgtb->addZeile(3, zeile);
		zeile->release();
		k->getNachrichtEncrypted((char*)&id, 4);
	}
	k->sendeEncrypted("\1", 1);
	cs.unlock();
	return dgtb;
}

// Gibt eine Tabelle von Dateien zurück.
//  gruppe: Die Id der Dateigruppe, zu der die Dateien gehöhren sollen
//  Gibt bei misserfolg 0 zurück
Framework::KSGTDatei* PatchClient::getDateiListe(int gruppe)
{
	cs.lock();
	if (!k)
	{
		err = "Der Client ist nicht verbunden.";
		cs.unlock();
		return 0;
	}
	k->sendeEncrypted("\x9", 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 = msg;
		delete[] msg;
		cs.unlock();
		return 0;
	}
	k->sendeEncrypted((char*)&gruppe, 4);
	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 = msg;
		delete[] msg;
		cs.unlock();
		return 0;
	}
	KSGTDatei* dtb = new KSGTDatei();
	int län = 0;
	k->getNachrichtEncrypted((char*)&län, 4);
	while (län)
	{
		RCArray< Text >* zeile = new RCArray< Text >();
		zeile->set(new Text("1"), 0);
		char* pfad = new char[län + 1];
		pfad[län] = 0;
		k->getNachrichtEncrypted(pfad, län);
		zeile->set(new Text(pfad), 1);
		delete[] pfad;
		int vs = 0;
		k->getNachrichtEncrypted((char*)&vs, 4);
		Text* vsT = new Text();
		vsT->append(vs);
		zeile->set(vsT, 2);
		dtb->addZeile(3, zeile);
		zeile->release();
		k->getNachrichtEncrypted((char*)&län, 4);
	}
	k->getNachrichtEncrypted((char*)&län, 4);
	while (län)
	{
		RCArray< Text >* zeile = new RCArray< Text >();
		zeile->set(new Text("0"), 0);
		char* pfad = new char[län + 1];
		pfad[län] = 0;
		k->getNachrichtEncrypted(pfad, län);
		zeile->set(new Text(pfad), 1);
		delete[] pfad;
		dtb->addZeile(2, zeile);
		zeile->release();
		k->getNachrichtEncrypted((char*)&län, 4);
	}
	cs.unlock();
	return dtb;
}

// Gibt die Größe einer Datei in bytes zurück
//  gruppe: Die Id der Dateigruppe der Datei
//  pfad: Der Pfad der Datei
__int64 PatchClient::getDateiGröße(int gruppe, const char* pfad)
{
	cs.lock();
	if (!k)
	{
		err = "Der Client ist nicht verbunden.";
		cs.unlock();
		return 0;
	}
	k->sendeEncrypted("\xA", 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 = msg;
		delete[] msg;
		cs.unlock();
		return 0;
	}
	k->sendeEncrypted((char*)&gruppe, 4);
	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 = msg;
		delete[] msg;
		cs.unlock();
		return 0;
	}
	if (ret == 2)
	{ // verweis auf anderen Server
		int p = 0;
		k->getNachrichtEncrypted((char*)&p, 4);
		port = (unsigned short)p;
		int län = 0;
		k->getNachrichtEncrypted((char*)&län, 4);
		char* ip = new char[län + 1];
		ip[län] = 0;
		k->getNachrichtEncrypted(ip, län);
		this->ip = ip;
		delete[]ip;
		if (!trenne(0))
		{
			err = "Fehler beim wechseln des Servers: Die Verbindung konnte nicht getrennt werden.";
			cs.unlock();
			return 0;
		}
		if (!verbinde())
		{
			err = "Fehler beim wechseln des Servers: Die Verbindung konnte nicht hergestellt werden.";
			cs.unlock();
			return 0;
		}
		cs.unlock();
		return getDateiGröße(gruppe, pfad);
	}
	int län = textLength(pfad);
	k->sendeEncrypted((char*)&län, 4);
	k->sendeEncrypted(pfad, län);
	__int64 größe = 0;
	k->getNachrichtEncrypted((char*)&größe, 8);
	cs.unlock();
	return größe;
}

// Lädt eine Datei herunter
//  gruppe: Die Dateigruppe der Datei
//  start: Der Index des bytes, bei dem der download begonnen werden soll (Enthält im Falle eines Abbruchs die Position, von welcher aus als nächstes heruntergeladen werden muss)
//  pfad: Der Pfad der Datei
//  zielPfad: Der Pfad, an den die Datei gespeichert werden soll
//  zFb: Ein Fortschrittsbalken, der automatisch aktualisiert wird
//  abbruch: Wenn diese Variable während des Vorgangs auf 1 gesetzt wird, so wird das Herunterladen abgebrochen.
//  maxbps: Die Anzahl der bytes pro Sekunde, die maximal übertragen werden sollen
bool PatchClient::downloadDatei(int gruppe, __int64* start, const char* pfad, const char* zielPfad, Framework::FBalken* zFb, bool* abbruch, int maxbps)
{
	cs.lock();
	if (!k)
	{
		err = "Der Client ist nicht verbunden.";
		cs.unlock();
		return 0;
	}
	Datei* zielD = new Datei();
	zielD->setDatei(zielPfad);
	if (!zielD->existiert())
		zielD->erstellen();
	bool ok = 0;
	if (!(*start)) // datei neu erstellen
		ok = zielD->open(Datei::Style::schreiben);
	else // datei weiterschreiben
		ok = zielD->open(Datei::Style::schreiben | Datei::Style::lesen);
	if (!ok)
	{
		zielD->release();
		err = "Die Datei konnte nicht zum schreiben geöffnet werden.";
		cs.unlock();
		return 0;
	}
	zielD->setSPosition(*start, 0);
	k->sendeEncrypted("\xB", 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 = msg;
		delete[] msg;
		zielD->close();
		zielD->release();
		cs.unlock();
		return 0;
	}
	k->sendeEncrypted((char*)&gruppe, 4);
	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 = msg;
		delete[] msg;
		zielD->close();
		zielD->release();
		cs.unlock();
		return 0;
	}
	if (ret == 2)
	{ // verweis auf anderen Server
		int p = 0;
		k->getNachrichtEncrypted((char*)&p, 4);
		port = (unsigned short)p;
		int län = 0;
		k->getNachrichtEncrypted((char*)&län, 4);
		char* ip = new char[län + 1];
		ip[län] = 0;
		k->getNachrichtEncrypted(ip, län);
		this->ip = ip;
		delete[] ip;
		if (!trenne(0))
		{
			zielD->close();
			zielD->release();
			err = "Fehler beim wechseln des Servers: Die Verbindung konnte nicht getrennt werden.";
			cs.unlock();
			return 0;
		}
		if (!verbinde())
		{
			zielD->close();
			zielD->release();
			err = "Fehler beim wechseln des Servers: Die Verbindung konnte nicht hergestellt werden.";
			cs.unlock();
			return 0;
		}
		zielD->close();
		zielD->release();
		cs.unlock();
		return downloadDatei(gruppe, start, pfad, zielPfad, zFb, abbruch, maxbps);
	}
	int län = textLength(pfad);
	k->sendeEncrypted((char*)&län, 4);
	k->sendeEncrypted(pfad, län);
	k->sendeEncrypted((char*)start, 8);
	char* bytes = new char[2048];
	unsigned short byteLän = 0;
	k->getNachricht((char*)&byteLän, 2);
	ZeitMesser* zMess = new ZeitMesser();
	zMess->messungStart();
	if (byteLän)
	{
		int bps = 0;
		double sec = 0;
		while (1)
		{
			k->getNachricht(bytes, byteLän);
			zielD->schreibe(bytes, byteLän);
			if (zFb)
				zFb->aktionPlus(byteLän);
			(*start) += byteLän;
			bps += byteLän;
			if (byteLän == 2048)
			{
				if ((*abbruch))
				{
					zielD->close();
					zielD->release();
					k->trenne();
					k = (Network::Klient*)k->release();
					delete[] bytes;
					zMess->release();
					cs.unlock();
					return 1;
				}
				k->getNachricht((char*)&byteLän, 2); // sendelänge empfangen
				if (!byteLän)
					break;
			}
			else
				break;
			if (maxbps)
			{
				zMess->messungEnde();
				sec += zMess->getSekunden();
				zMess->messungStart();
				if (sec >= 1)
				{
					sec = 0;
					bps = 0;
				}
				while (bps >= maxbps)
				{
					Sleep(10);
					zMess->messungEnde();
					sec += zMess->getSekunden();
					zMess->messungStart();
					if (sec >= 1)
					{
						sec = 0;
						bps = 0;
					}
				}
			}
		}
	}
	zMess->release();
	delete[] bytes;
	k->sendeEncrypted("\1", 1);
	zielD->close();
	zielD->release();
	cs.unlock();
	return 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 PatchClient::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 Patch 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 Patch 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 PatchClient::istVerbunden() const
{
	return k != 0;
}

// Gibt die Anzahl von übertragenen Bytes seit dem letzten Aufruf zurück
int PatchClient::getDownload() const
{
	return k ? k->getDownloadBytes(1) : 0;
}

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