made char * const

Network/HttpRequest.cpp

@@ -8,171 +8,171 @@ using namespace Network;
 using namespace HTTP;
 
 
-PostRequest::PostRequest( const char *path, const char *host, const char *data, const char *contentType, unsigned short port, bool useSSL )
-    : ReferenceCounter()
+PostRequest::PostRequest(const char* path, const char* host, const char* data, const char* contentType, unsigned short port, bool useSSL)
+	: ReferenceCounter()
 {
-    this->path = path;
-    this->host = host;
-    this->data = data;
-    this->contentType = contentType;
-    this->port = port;
-    this->useSSL = useSSL;
+	this->path = path;
+	this->host = host;
+	this->data = data;
+	this->contentType = contentType;
+	this->port = port;
+	this->useSSL = useSSL;
 }
 
-Answer *PostRequest::execute() const
+Answer* PostRequest::execute() const
 {
-    Text message = "POST ";
-    message += path;
-    message += " HTTP/1.1\r\n";
-    message += "Host: ";
-    message += host;
-    message += "\r\nContent-Type: ";
-    message += contentType;
-    message += "; charset=latin-1\r\nContent-Length: ";
-    message += data.getLength();
-    message += "\r\n\r\n";
-    message += data;
-    SSLKlient httpsK;
-    Klient httpK;
-    if( useSSL )
-    {
-        if( !httpsK.verbinde( port, host ) )
-            return 0;
-        httpsK.sende( message, message.getLength() );
-    }
-    else
-    {
-        if( !httpK.verbinde( port, host ) )
-            return 0;
-        httpK.sende( message, message.getLength() );
-    }
-    int length = -1;
-    bool lastn = 0;
-    Text answer;
-    do
-    {
-        char buff[ 2 ];
-        buff[ 1 ] = 0;
-        if( ( useSSL && httpsK.getNachricht( buff, 1 ) ) || ( !useSSL && httpK.getNachricht( buff, 1 ) ) )
-        {
-            answer += buff;
-            if( buff[ 0 ] == '\n' )
-            {
-                if( length <= 0 )
-                {
-                    int p = answer.positionVon( "Content-Length: " );
-                    if( p >= 0 )
-                    {
-                        p += 16;
-                        Text *len = answer.getTeilText( p );
-                        len->remove( len->positionVon( "\n" ), len->getLength() );
-                        len->remove( "\r" );
-                        length = *len;
-                        len->release();
-                    }
-                }
-                else if( lastn )
-                { // header der antwort ist vorbei
-                    char *buff = new char[ length + 1 ];
-                    buff[ length ] = 0;
-                    if( length > 0 )
-                    {
-                        if( useSSL )
-                            httpsK.getNachricht( buff, length );
-                        else
-                            httpK.getNachricht( buff, length );
-                    }
-                    answer += buff;
-                    delete[] buff;
-                    break;
-                }
-                lastn = 1;
-            }
-            else if( buff[ 0 ] != '\r' )
-                lastn = 0;
-        }
-        else
-            break;
-    } while( ( useSSL && httpsK.hatNachricht( 1000 ) ) || ( !useSSL && httpK.hatNachricht( 1000 ) ) );
-    if( answer.getLength() )
-        return new Answer( answer );
-    return 0;
+	Text message = "POST ";
+	message += path;
+	message += " HTTP/1.1\r\n";
+	message += "Host: ";
+	message += host;
+	message += "\r\nContent-Type: ";
+	message += contentType;
+	message += "; charset=latin-1\r\nContent-Length: ";
+	message += data.getLength();
+	message += "\r\n\r\n";
+	message += data;
+	SSLKlient httpsK;
+	Klient httpK;
+	if (useSSL)
+	{
+		if (!httpsK.verbinde(port, host))
+			return 0;
+		httpsK.sende(message, message.getLength());
+	}
+	else
+	{
+		if (!httpK.verbinde(port, host))
+			return 0;
+		httpK.sende(message, message.getLength());
+	}
+	int length = -1;
+	bool lastn = 0;
+	Text answer;
+	do
+	{
+		char buff[2];
+		buff[1] = 0;
+		if ((useSSL && httpsK.getNachricht(buff, 1)) || (!useSSL && httpK.getNachricht(buff, 1)))
+		{
+			answer += buff;
+			if (buff[0] == '\n')
+			{
+				if (length <= 0)
+				{
+					int p = answer.positionVon("Content-Length: ");
+					if (p >= 0)
+					{
+						p += 16;
+						Text* len = answer.getTeilText(p);
+						len->remove(len->positionVon("\n"), len->getLength());
+						len->remove("\r");
+						length = *len;
+						len->release();
+					}
+				}
+				else if (lastn)
+				{ // header der antwort ist vorbei
+					char* buff = new char[length + 1];
+					buff[length] = 0;
+					if (length > 0)
+					{
+						if (useSSL)
+							httpsK.getNachricht(buff, length);
+						else
+							httpK.getNachricht(buff, length);
+					}
+					answer += buff;
+					delete[] buff;
+					break;
+				}
+				lastn = 1;
+			}
+			else if (buff[0] != '\r')
+				lastn = 0;
+		}
+		else
+			break;
+	} while ((useSSL && httpsK.hatNachricht(1000)) || (!useSSL && httpK.hatNachricht(1000)));
+	if (answer.getLength())
+		return new Answer(answer);
+	return 0;
 }
 
 
-Answer::Answer( const char *answer )
-    : ReferenceCounter()
+Answer::Answer(const char* answer)
+	: ReferenceCounter()
 {
-    all = answer;
-    TextReader reader( new Text( answer ) );
-    // parse header
-    Text *line = reader.leseZeile();
-    line->remove( "\r\n" );
-    line->remove( "\n" );
-    header += *line;
-    header += "\n";
-    int trenn = line->positionVon( " " );
-    Text *tmp = line->getTeilText( 0, trenn );
-    this->protocol = *tmp;
-    tmp->release();
-    line->remove( 0, trenn + 1 );
-    trenn = line->positionVon( " " );
-    tmp = line->getTeilText( 0, trenn );
-    this->statusNumber = *tmp;
-    tmp->release();
-    line->remove( 0, trenn + 1 );
-    this->statusText = *line;
-    line->release();
-    while( !reader.istEnde() )
-    {
-        Text *line = reader.leseZeile();
-        line->remove( "\r\n" );
-        line->remove( "\n" );
-        if( line->getLength() > 0 )
-        {
-            header += *line;
-            header += "\n";
-        }
-        if( line->positionVon( "Date:" ) == 0 )
-            this->date = line->getText() + 6;
-        if( line->positionVon( "Content-Type:" ) == 0 )
-            this->contentType = line->getText() + 14;
-        int len = line->getLength();
-        line->release();
-        if( len == 0 )
-            break;
-    }
-    // parse body
-    if( !reader.istEnde() )
-        this->data = answer + reader.getLPosition();
+	all = answer;
+	TextReader reader(new Text(answer));
+	// parse header
+	Text* line = reader.leseZeile();
+	line->remove("\r\n");
+	line->remove("\n");
+	header += *line;
+	header += "\n";
+	int trenn = line->positionVon(" ");
+	Text* tmp = line->getTeilText(0, trenn);
+	this->protocol = *tmp;
+	tmp->release();
+	line->remove(0, trenn + 1);
+	trenn = line->positionVon(" ");
+	tmp = line->getTeilText(0, trenn);
+	this->statusNumber = *tmp;
+	tmp->release();
+	line->remove(0, trenn + 1);
+	this->statusText = *line;
+	line->release();
+	while (!reader.istEnde())
+	{
+		Text* line = reader.leseZeile();
+		line->remove("\r\n");
+		line->remove("\n");
+		if (line->getLength() > 0)
+		{
+			header += *line;
+			header += "\n";
+		}
+		if (line->positionVon("Date:") == 0)
+			this->date = line->getText() + 6;
+		if (line->positionVon("Content-Type:") == 0)
+			this->contentType = line->getText() + 14;
+		int len = line->getLength();
+		line->release();
+		if (len == 0)
+			break;
+	}
+	// parse body
+	if (!reader.istEnde())
+		this->data = answer + reader.getLPosition();
 }
 
-const char *Answer::getContentType() const
+const char* Answer::getContentType() const
 {
-    return contentType;
+	return contentType;
 }
 
-const char *Answer::getData() const
+const char* Answer::getData() const
 {
-    return data;
+	return data;
 }
 
 int Answer::getStatusCode() const
 {
-    return statusNumber;
+	return statusNumber;
 }
 
-const char *Answer::getStatusText() const
+const char* Answer::getStatusText() const
 {
-    return statusText;
+	return statusText;
 }
 
-const char *Answer::getDate() const
+const char* Answer::getDate() const
 {
-    return date;
+	return date;
 }
 
-const char *Answer::getAll() const
+const char* Answer::getAll() const
 {
-    return all;
+	return all;
 }

Network/HttpRequest.h

@@ -4,45 +4,44 @@
 
 namespace Network
 {
-    namespace HTTP
-    {
-        class Answer : public virtual Framework::ReferenceCounter
-        {
-        private:
-            Framework::Text protocol;
-            int statusNumber;
-            Framework::Text statusText;
-            Framework::Text date;
-            Framework::Text contentType;
-            Framework::Text header;
-            Framework::Text data;
-            Framework::Text all;
+	namespace HTTP
+	{
+		class Answer : public virtual Framework::ReferenceCounter
+		{
+		private:
+			Framework::Text protocol;
+			int statusNumber;
+			Framework::Text statusText;
+			Framework::Text date;
+			Framework::Text contentType;
+			Framework::Text header;
+			Framework::Text data;
+			Framework::Text all;
 
-        public:
-            __declspec( dllexport ) Answer( const char *answer );
+		public:
+			__declspec(dllexport) Answer(const char* answer);
+			__declspec(dllexport) const char* getContentType() const;
+			__declspec(dllexport) const char* getData() const;
+			__declspec(dllexport) int getStatusCode() const;
+			__declspec(dllexport) const char* getStatusText() const;
+			__declspec(dllexport) const char* getDate() const;
+			__declspec(dllexport) const char* getAll() const;
+		};
 
-            __declspec( dllexport ) const char *getContentType() const;
-            __declspec( dllexport ) const char *getData() const;
-            __declspec( dllexport ) int getStatusCode() const;
-            __declspec( dllexport ) const char *getStatusText() const;
-            __declspec( dllexport ) const char *getDate() const;
-            __declspec( dllexport ) const char *getAll() const;
-        };
+		class PostRequest : public virtual Framework::ReferenceCounter
+		{
+		private:
+			Framework::Text path;
+			Framework::Text host;
+			Framework::Text contentType;
+			Framework::Text data;
+			unsigned short port;
+			bool useSSL;
 
-        class PostRequest : public virtual Framework::ReferenceCounter
-        {
-        private:
-            Framework::Text path;
-            Framework::Text host;
-            Framework::Text contentType;
-            Framework::Text data;
-            unsigned short port;
-            bool useSSL;
+		public:
+			__declspec(dllexport) PostRequest(const char* path, const char* host, const char* data, const char* contentType, unsigned short port, bool useSSL = false);
 
-        public:
-            __declspec( dllexport ) PostRequest( const char *path, const char *host, const char *data, const char *contentType, unsigned short port, bool useSSL = false );
-
-            __declspec( dllexport ) Answer *execute() const;
-        };
-    }
+			__declspec(dllexport) Answer* execute() const;
+		};
+	}
 }

Network/Klient.cpp

@@ -14,340 +14,340 @@ using namespace Network;
 // inhalt der Klient Klasse aus Klient.h
 // Konstruktor 
 Klient::Klient()
-    : ReferenceCounter()
+	: ReferenceCounter()
 {
-    memset( &server, 0, sizeof( server ) );
-    server.sin_family = AF_INET;
-    downStreamBytes = 0;
-    upStreamBytes = 0;
-    sock = 0;
-    sendeKey = 0;
-    empfangKey = 0;
+	memset(&server, 0, sizeof(server));
+	server.sin_family = AF_INET;
+	downStreamBytes = 0;
+	upStreamBytes = 0;
+	sock = 0;
+	sendeKey = 0;
+	empfangKey = 0;
 }
 
 // Destruktoe 
 Klient::~Klient()
 {
-    if( sock )
-        trenne();
-    if( sendeKey )
-        sendeKey->release();
-    if( empfangKey )
-        empfangKey->release();
+	if (sock)
+		trenne();
+	if (sendeKey)
+		sendeKey->release();
+	if (empfangKey)
+		empfangKey->release();
 }
 
 // nicht constant 
-void Klient::setSendeKeyZ( Encryption::Key* key ) // Setzt den Key fürs Senden
+void Klient::setSendeKeyZ(Encryption::Key* key) // Setzt den Key fürs Senden
 {
-    if( sendeKey )
-        sendeKey->release();
-    sendeKey = key;
+	if (sendeKey)
+		sendeKey->release();
+	sendeKey = key;
 }
 
-void Klient::setEmpfangKeyZ( Encryption::Key* key ) // Setzt den Key fürs Empfangen
+void Klient::setEmpfangKeyZ(Encryption::Key* key) // Setzt den Key fürs Empfangen
 {
-    if( empfangKey )
-        empfangKey->release();
-    empfangKey = key;
+	if (empfangKey)
+		empfangKey->release();
+	empfangKey = key;
 }
 
-void Klient::setSendeKey( char* key, int len ) // Setzt den Key fürs Senden
+void Klient::setSendeKey(const char* key, int len) // Setzt den Key fürs Senden
 {
-    if( !sendeKey )
-        sendeKey = new Encryption::Key();
-    sendeKey->setKey( key, len );
+	if (!sendeKey)
+		sendeKey = new Encryption::Key();
+	sendeKey->setKey(key, len);
 }
 
-void Klient::setEmpfangKey( char* key, int len ) // Setzt den Key fürs Empfangen
+void Klient::setEmpfangKey(const char* key, int len) // Setzt den Key fürs Empfangen
 {
-    if( !empfangKey )
-        empfangKey = new Encryption::Key();
-    empfangKey->setKey( key, len );
+	if (!empfangKey)
+		empfangKey = new Encryption::Key();
+	empfangKey->setKey(key, len);
 }
 
-bool Klient::verbinde( unsigned short port, const char* ip ) // verbindet mit Server
+bool Klient::verbinde(unsigned short port, const char* ip) // verbindet mit Server
 {
-    if( sendeKey )
-        sendeKey->setPos( 0 );
-    if( empfangKey )
-        empfangKey->setPos( 0 );
-    if( sock )
-        closesocket( sock );
-    sock = socket( AF_INET, SOCK_STREAM, IPPROTO_TCP );
-    long sIp = inet_addr( ip ); // ip addresse
-    if( sIp == INADDR_NONE )
-    {
-        struct hostent* pHostInfo = gethostbyname( ip );
-        if( pHostInfo == 0 )
-            return 0;
-        sIp = *(long*)pHostInfo->h_addr_list[ 0 ];
-    }
-    memcpy( (char*)&server.sin_addr, &sIp, sizeof( sIp ) );
-    server.sin_port = htons( port ); // port
-    if( connect( sock, (struct sockaddr*)&server, sizeof( server ) ) < 0 ) // verbinden
-        return 0; // Fehler
-    return 1;
+	if (sendeKey)
+		sendeKey->setPos(0);
+	if (empfangKey)
+		empfangKey->setPos(0);
+	if (sock)
+		closesocket(sock);
+	sock = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
+	long sIp = inet_addr(ip); // ip addresse
+	if (sIp == INADDR_NONE)
+	{
+		struct hostent* pHostInfo = gethostbyname(ip);
+		if (pHostInfo == 0)
+			return 0;
+		sIp = *(long*)pHostInfo->h_addr_list[0];
+	}
+	memcpy((char*)&server.sin_addr, &sIp, sizeof(sIp));
+	server.sin_port = htons(port); // port
+	if (connect(sock, (struct sockaddr*)&server, sizeof(server)) < 0) // verbinden
+		return 0; // Fehler
+	return 1;
 }
 
-bool Klient::sende( const char* nachricht, int len ) // sendet zum Server
+bool Klient::sende(const char* nachricht, int len) // sendet zum Server
 {
-    int ll = 0;
-    while( len > 0 )
-    {
+	int ll = 0;
+	while (len > 0)
+	{
 #ifdef WIN32
-        int l = send( sock, nachricht + ll, len, 0 );
+		int l = send(sock, nachricht + ll, len, 0);
 #else
-        int l = (int)send( sock, nachricht + ll, len, MSG_NOSIGNAL );
+		int l = (int)send(sock, nachricht + ll, len, MSG_NOSIGNAL);
 #endif
-        if( l <= 0 )
-            return 0; // Fehler
-        len -= l;
-        ll += l;
-    }
-    upStreamBytes += ll;
-    return 1;
+		if (l <= 0)
+			return 0; // Fehler
+		len -= l;
+		ll += l;
+	}
+	upStreamBytes += ll;
+	return 1;
 }
 
-bool Klient::getNachricht( char* nachricht, int len ) // empfängt Nachricht
+bool Klient::getNachricht(char* nachricht, int len) // empfängt Nachricht
 {
-    int ll = 0;
-    while( len > 0 )
-    {
-        int l = (int)recv( sock, nachricht + ll, len, MSG_WAITALL );
-        if( l <= 0 )
-            return 0; // Fehler
-        len -= l;
-        ll += l;
-    }
-    downStreamBytes += ll;
-    return 1;
+	int ll = 0;
+	while (len > 0)
+	{
+		int l = (int)recv(sock, nachricht + ll, len, MSG_WAITALL);
+		if (l <= 0)
+			return 0; // Fehler
+		len -= l;
+		ll += l;
+	}
+	downStreamBytes += ll;
+	return 1;
 }
 
-bool Klient::sendeEncrypted( const char* nachricht, int len ) // sendet zum Server
+bool Klient::sendeEncrypted(const char* nachricht, int len) // sendet zum Server
 {
-    if( !sendeKey )
-        return sende( nachricht, len );
-    Encryption::Bytes* n = new Encryption::Bytes( nachricht, len );
-    sendeKey->codieren( dynamic_cast<Framework::Encryption::Bytes*>(n->getThis()) );
-    int ll = 0;
-    while( len > 0 )
-    {
+	if (!sendeKey)
+		return sende(nachricht, len);
+	Encryption::Bytes* n = new Encryption::Bytes(nachricht, len);
+	sendeKey->codieren(dynamic_cast<Framework::Encryption::Bytes*>(n->getThis()));
+	int ll = 0;
+	while (len > 0)
+	{
 #ifdef WIN32
-        int l = send( sock, n->getBytes() + ll, len, 0 );
+		int l = send(sock, n->getBytes() + ll, len, 0);
 #else
-        int l = (int)send( sock, n->getBytes() + ll, len, MSG_NOSIGNAL );
+		int l = (int)send(sock, n->getBytes() + ll, len, MSG_NOSIGNAL);
 #endif
-        if( l <= 0 )
-        {
-            n->release();
-            return 0; // Fehler
-        }
-        len -= l;
-        ll += l;
-    }
-    upStreamBytes += ll;
-    n->release();
-    return 1;
+		if (l <= 0)
+		{
+			n->release();
+			return 0; // Fehler
+		}
+		len -= l;
+		ll += l;
+	}
+	upStreamBytes += ll;
+	n->release();
+	return 1;
 }
 
-bool Klient::getNachrichtEncrypted( char* nachricht, int len ) // empfängt Nachricht
+bool Klient::getNachrichtEncrypted(char* nachricht, int len) // empfängt Nachricht
 {
-    if( !empfangKey )
-        return getNachricht( nachricht, len );
-    int ll = 0;
-    while( len > 0 )
-    {
-        int l = (int)recv( sock, nachricht + ll, len, MSG_WAITALL );
-        if( l <= 0 )
-            return 0; // Fehler
-        len -= l;
-        ll += l;
-    }
-    Encryption::Bytes* n = new Encryption::Bytes();
-    n->setBytesZ( nachricht, ll );
-    empfangKey->decodieren( n );
-    downStreamBytes += ll;
-    return 1;
+	if (!empfangKey)
+		return getNachricht(nachricht, len);
+	int ll = 0;
+	while (len > 0)
+	{
+		int l = (int)recv(sock, nachricht + ll, len, MSG_WAITALL);
+		if (l <= 0)
+			return 0; // Fehler
+		len -= l;
+		ll += l;
+	}
+	Encryption::Bytes* n = new Encryption::Bytes();
+	n->setBytesZ(nachricht, ll);
+	empfangKey->decodieren(n);
+	downStreamBytes += ll;
+	return 1;
 }
 
-int Klient::getDownloadBytes( bool reset ) // gibt die anzahl von empfangen bytes zurück
+int Klient::getDownloadBytes(bool reset) // gibt die anzahl von empfangen bytes zurück
 {
-    int ret = downStreamBytes;
-    if( reset )
-        downStreamBytes = 0;
-    return ret;
+	int ret = downStreamBytes;
+	if (reset)
+		downStreamBytes = 0;
+	return ret;
 }
 
-int Klient::getUploadBytes( bool reset ) // gibt die anzahl von versendeter bytes zurück
+int Klient::getUploadBytes(bool reset) // gibt die anzahl von versendeter bytes zurück
 {
-    int ret = upStreamBytes;
-    if( reset )
-        upStreamBytes = 0;
-    return ret;
+	int ret = upStreamBytes;
+	if (reset)
+		upStreamBytes = 0;
+	return ret;
 }
 
 bool Klient::trenne() // Trennt die Verbindung zum Server
 {
-    if( !sock )
-        return 1;
-    if( sendeKey )
-        sendeKey->setPos( 0 );
-    if( empfangKey )
-        empfangKey->setPos( 0 );
-    if( closesocket( sock ) < 0 ) // verbindung Trennen
-        return 0; // Fehler
-    sock = 0;
-    return 1;
+	if (!sock)
+		return 1;
+	if (sendeKey)
+		sendeKey->setPos(0);
+	if (empfangKey)
+		empfangKey->setPos(0);
+	if (closesocket(sock) < 0) // verbindung Trennen
+		return 0; // Fehler
+	sock = 0;
+	return 1;
 }
 
 // constant
-bool Klient::hatNachricht( int zeit ) // Wartet eine Zeit Lang auf eine Nachricht
+bool Klient::hatNachricht(int zeit) // Wartet eine Zeit Lang auf eine Nachricht
 {
-    fd_set set;
-    FD_ZERO( &set );
-    FD_SET( sock, &set );
-    timeval time = { zeit / 1000, zeit };
-    return select( 0, &set, 0, 0, &time ) == 1;
+	fd_set set;
+	FD_ZERO(&set);
+	FD_SET(sock, &set);
+	timeval time = { zeit / 1000, zeit };
+	return select(0, &set, 0, 0, &time) == 1;
 }
 
 unsigned short Klient::getServerPort() const // gibt den Port zurück
 {
-    return htons( server.sin_port );
+	return htons(server.sin_port);
 }
 
 const char* Klient::getServerIp() const // gibt die Ip zurück
 {
-    return inet_ntoa( server.sin_addr );
+	return inet_ntoa(server.sin_addr);
 }
 
 bool Klient::waitForNextMessage() const // wartet bis es etwas zu empfangen gibt
 {
-    char c;
-    int l = (int)recv( sock, &c, 1, MSG_WAITALL | MSG_PEEK );
-    if( l <= 0 )
-        return 0; // Fehler
-    return 1;
+	char c;
+	int l = (int)recv(sock, &c, 1, MSG_WAITALL | MSG_PEEK);
+	if (l <= 0)
+		return 0; // Fehler
+	return 1;
 }
 
 
 // Inhalt der SSLKlient Klasse aus Klient.h
-        // Konstruktor 
+		// Konstruktor 
 SSLKlient::SSLKlient()
-    : ReferenceCounter()
+	: ReferenceCounter()
 {
-    ctx = SSL_CTX_new( TLS_client_method() );
-    SSL_CTX_set_min_proto_version( ctx, TLS1_2_VERSION );
-    SSL_CTX_set_max_proto_version( ctx, TLS1_3_VERSION );
-    ip = 0;
-    port = 0;
-    bio = BIO_new_ssl_connect( ctx );
-    BIO_get_ssl( bio, &ssl );
-    downStreamBytes = 0;
-    upStreamBytes = 0;
-    connected = 0;
+	ctx = SSL_CTX_new(TLS_client_method());
+	SSL_CTX_set_min_proto_version(ctx, TLS1_2_VERSION);
+	SSL_CTX_set_max_proto_version(ctx, TLS1_3_VERSION);
+	ip = 0;
+	port = 0;
+	bio = BIO_new_ssl_connect(ctx);
+	BIO_get_ssl(bio, &ssl);
+	downStreamBytes = 0;
+	upStreamBytes = 0;
+	connected = 0;
 }
 
 // Destruktor 
 SSLKlient::~SSLKlient()
 {
-    if( this->ip )
-        this->ip->release();
-    if( connected )
-        trenne();
-    BIO_free_all( bio );
-    SSL_CTX_free( ctx );
+	if (this->ip)
+		this->ip->release();
+	if (connected)
+		trenne();
+	BIO_free_all(bio);
+	SSL_CTX_free(ctx);
 #ifdef WIN32
-    OPENSSL_thread_stop();
+	OPENSSL_thread_stop();
 #endif
 }
 
-bool SSLKlient::verbinde( unsigned short port, const char* ip ) // verbindet mit Server
+bool SSLKlient::verbinde(unsigned short port, const char* ip) // verbindet mit Server
 {
-    this->port = port;
-    if( this->ip )
-        this->ip->release();
-    this->ip = new Text( ip );
-    Text adr = ip;
-    adr += ":";
-    adr += port;
-    BIO_set_conn_hostname( bio, adr );
-    connected = BIO_do_connect( bio ) > 0;
-    if( connected && BIO_do_handshake( bio ) <= 0 )
-        trenne();
-    return connected;
+	this->port = port;
+	if (this->ip)
+		this->ip->release();
+	this->ip = new Text(ip);
+	Text adr = ip;
+	adr += ":";
+	adr += port;
+	BIO_set_conn_hostname(bio, adr);
+	connected = BIO_do_connect(bio) > 0;
+	if (connected && BIO_do_handshake(bio) <= 0)
+		trenne();
+	return connected;
 }
 
-bool SSLKlient::sende( const char* nachricht, int len ) // sendet zum Server
+bool SSLKlient::sende(const char* nachricht, int len) // sendet zum Server
 {
-    int ll = 0;
-    while( len > 0 )
-    {
-        int l = SSL_write( ssl, nachricht + ll, len );
-        if( l <= 0 )
-            return 0; // Fehler
-        len -= l;
-        ll += l;
-    }
-    upStreamBytes += ll;
-    return 1;
+	int ll = 0;
+	while (len > 0)
+	{
+		int l = SSL_write(ssl, nachricht + ll, len);
+		if (l <= 0)
+			return 0; // Fehler
+		len -= l;
+		ll += l;
+	}
+	upStreamBytes += ll;
+	return 1;
 }
 
-bool SSLKlient::getNachricht( char* nachricht, int len ) // empfängt Nachricht
+bool SSLKlient::getNachricht(char* nachricht, int len) // empfängt Nachricht
 {
-    if( !connected )
-        return 0;
-    int ll = 0;
-    while( len > 0 )
-    {
-        int l = SSL_read( ssl, nachricht + ll, len );
-        if( l <= 0 )
-            return 0; // Fehler
-        len -= l;
-        ll += l;
-    }
-    downStreamBytes += ll;
-    return 1;
+	if (!connected)
+		return 0;
+	int ll = 0;
+	while (len > 0)
+	{
+		int l = SSL_read(ssl, nachricht + ll, len);
+		if (l <= 0)
+			return 0; // Fehler
+		len -= l;
+		ll += l;
+	}
+	downStreamBytes += ll;
+	return 1;
 }
 
-int SSLKlient::getDownloadBytes( bool reset ) // gibt die anzahl von empfangen bytes zurück
+int SSLKlient::getDownloadBytes(bool reset) // gibt die anzahl von empfangen bytes zurück
 {
-    int ret = downStreamBytes;
-    if( reset )
-        downStreamBytes = 0;
-    return ret;
+	int ret = downStreamBytes;
+	if (reset)
+		downStreamBytes = 0;
+	return ret;
 }
 
-int SSLKlient::getUploadBytes( bool reset ) // gibt die anzahl von versendeter bytes zurück
+int SSLKlient::getUploadBytes(bool reset) // gibt die anzahl von versendeter bytes zurück
 {
-    int ret = upStreamBytes;
-    if( reset )
-        upStreamBytes = 0;
-    return ret;
+	int ret = upStreamBytes;
+	if (reset)
+		upStreamBytes = 0;
+	return ret;
 }
 
 bool SSLKlient::trenne() // Trennt die Verbindung zum Server
 {
-    BIO_ssl_shutdown( bio );
-    connected = 0;
-    return 1;
+	BIO_ssl_shutdown(bio);
+	connected = 0;
+	return 1;
 }
 
 // constant 
-bool SSLKlient::hatNachricht( int zeit ) // Wartet eine Zeit Lang auf eine Nachricht
+bool SSLKlient::hatNachricht(int zeit) // Wartet eine Zeit Lang auf eine Nachricht
 {
-    fd_set set;
-    FD_ZERO( &set );
-    FD_SET( SSL_get_rfd( ssl ), &set );
-    timeval time = { zeit / 1000, zeit };
-    return SSL_pending( ssl ) > 0 || select( 0, &set, 0, 0, &time ) == 1;
+	fd_set set;
+	FD_ZERO(&set);
+	FD_SET(SSL_get_rfd(ssl), &set);
+	timeval time = { zeit / 1000, zeit };
+	return SSL_pending(ssl) > 0 || select(0, &set, 0, 0, &time) == 1;
 }
 
 unsigned short SSLKlient::getServerPort() const // gibt den Port des Servers zurück
 {
-    return port;
+	return port;
 }
 
 const char* SSLKlient::getServerIp() const // gibt die Ip des Servers zurück
 {
-    return ip->getText();
+	return ip->getText();
 }

Network/Klient.h

@@ -12,83 +12,83 @@ struct BIO;
 
 namespace Framework
 {
-    namespace Encryption
-    {
-        class Key;
-    }
+	namespace Encryption
+	{
+		class Key;
+	}
 
-    class Text;
+	class Text;
 }
 
 using namespace Framework;
 
 namespace Network
 {
-    class Klient; // aus dieser Datei
+	class Klient; // aus dieser Datei
 
-    class Klient : public EncryptedVerbindung, public virtual ReferenceCounter
-    {
-    private:
-        SOCKET sock;
-        sockaddr_in server;
-        Encryption::Key* sendeKey;
-        Encryption::Key* empfangKey;
-        int downStreamBytes;
-        int upStreamBytes;
+	class Klient : public EncryptedVerbindung, public virtual ReferenceCounter
+	{
+	private:
+		SOCKET sock;
+		sockaddr_in server;
+		Encryption::Key* sendeKey;
+		Encryption::Key* empfangKey;
+		int downStreamBytes;
+		int upStreamBytes;
 
-    public:
-        // Konstruktor 
-        __declspec(dllexport) Klient();
-        // Destruktor 
-        __declspec(dllexport) ~Klient();
-        // nicht constant 
-        __declspec(dllexport) void setSendeKeyZ( Encryption::Key* key ); // Setzt den Schlüssel fürs Senden
-        __declspec(dllexport) void setEmpfangKeyZ( Encryption::Key* key ); // Setzt den Schlüssel fürs Empfangen
-        __declspec(dllexport) void setSendeKey( char* key, int len ); // Setzt den Schlüssel fürs Senden
-        __declspec(dllexport) void setEmpfangKey( char* key, int len ); // Setzt den Schlüssel fürs Empfangen
-        __declspec(dllexport) bool verbinde( unsigned short port, const char* ip ); // verbindet mit Server
-        __declspec(dllexport) bool sende( const char* nachricht, int len ) override; // sendet zum Server
-        __declspec(dllexport) bool getNachricht( char* nachricht, int len ) override; // empfängt Nachricht
-        __declspec(dllexport) bool sendeEncrypted( const char* nachricht, int len ) override; // sendet zum Server
-        __declspec(dllexport) bool getNachrichtEncrypted( char* nachricht, int len ) override; // empfängt Nachricht
-        __declspec(dllexport) int getDownloadBytes( bool reset ); // gibt die anzahl von empfangen bytes zurück
-        __declspec(dllexport) int getUploadBytes( bool reset ); // gibt die anzahl von versendeter bytes zurück
-        __declspec(dllexport) bool trenne(); // Trennt die Verbindung zum Server
-        // constant 
-        __declspec(dllexport) bool hatNachricht( int zeit ); // Wartet eine Zeit Lang auf eine Nachricht
-        __declspec(dllexport) unsigned short getServerPort() const; // gibt den Port des Servers zurück
-        __declspec(dllexport) const char* getServerIp() const; // gibt die Ip des Servers zurück
-        __declspec(dllexport) bool waitForNextMessage() const; // wartet bis es etwas zu empfangen gibt
-    };
+	public:
+		// Konstruktor 
+		__declspec(dllexport) Klient();
+		// Destruktor 
+		__declspec(dllexport) ~Klient();
+		// nicht constant 
+		__declspec(dllexport) void setSendeKeyZ(Encryption::Key* key); // Setzt den Schlüssel fürs Senden
+		__declspec(dllexport) void setEmpfangKeyZ(Encryption::Key* key); // Setzt den Schlüssel fürs Empfangen
+		__declspec(dllexport) void setSendeKey(const char* key, int len); // Setzt den Schlüssel fürs Senden
+		__declspec(dllexport) void setEmpfangKey(const char* key, int len); // Setzt den Schlüssel fürs Empfangen
+		__declspec(dllexport) bool verbinde(unsigned short port, const char* ip); // verbindet mit Server
+		__declspec(dllexport) bool sende(const char* nachricht, int len) override; // sendet zum Server
+		__declspec(dllexport) bool getNachricht(char* nachricht, int len) override; // empfängt Nachricht
+		__declspec(dllexport) bool sendeEncrypted(const char* nachricht, int len) override; // sendet zum Server
+		__declspec(dllexport) bool getNachrichtEncrypted(char* nachricht, int len) override; // empfängt Nachricht
+		__declspec(dllexport) int getDownloadBytes(bool reset); // gibt die anzahl von empfangen bytes zurück
+		__declspec(dllexport) int getUploadBytes(bool reset); // gibt die anzahl von versendeter bytes zurück
+		__declspec(dllexport) bool trenne(); // Trennt die Verbindung zum Server
+		// constant 
+		__declspec(dllexport) bool hatNachricht(int zeit); // Wartet eine Zeit Lang auf eine Nachricht
+		__declspec(dllexport) unsigned short getServerPort() const; // gibt den Port des Servers zurück
+		__declspec(dllexport) const char* getServerIp() const; // gibt die Ip des Servers zurück
+		__declspec(dllexport) bool waitForNextMessage() const; // wartet bis es etwas zu empfangen gibt
+	};
 
-    class SSLKlient : public Verbindung, public virtual ReferenceCounter
-    {
-    private:
-        unsigned short port;
-        Text* ip;
-        SSL_CTX* ctx;
-        SSL* ssl;
-        BIO* bio;
-        int downStreamBytes;
-        int upStreamBytes;
-        bool connected;
+	class SSLKlient : public Verbindung, public virtual ReferenceCounter
+	{
+	private:
+		unsigned short port;
+		Text* ip;
+		SSL_CTX* ctx;
+		SSL* ssl;
+		BIO* bio;
+		int downStreamBytes;
+		int upStreamBytes;
+		bool connected;
 
-    public:
-        // Konstruktor 
-        __declspec(dllexport) SSLKlient();
-        // Destruktor 
-        __declspec(dllexport) ~SSLKlient();
-        __declspec(dllexport) bool verbinde( unsigned short port, const char* ip ); // verbindet mit Server
-        __declspec(dllexport) bool sende( const char* nachricht, int len ) override; // sendet zum Server
-        __declspec(dllexport) bool getNachricht( char* nachricht, int len ) override; // empfängt Nachricht
-        __declspec(dllexport) int getDownloadBytes( bool reset ); // gibt die anzahl von empfangen bytes zurück
-        __declspec(dllexport) int getUploadBytes( bool reset ); // gibt die anzahl von versendeter bytes zurück
-        __declspec(dllexport) bool trenne(); // Trennt die Verbindung zum Server
-        // constant 
-        __declspec(dllexport) bool hatNachricht( int zeit ); // Wartet eine Zeit Lang auf eine Nachricht
-        __declspec(dllexport) unsigned short getServerPort() const; // gibt den Port des Servers zurück
-        __declspec(dllexport) const char* getServerIp() const; // gibt die Ip des Servers zurück
-    };
+	public:
+		// Konstruktor 
+		__declspec(dllexport) SSLKlient();
+		// Destruktor 
+		__declspec(dllexport) ~SSLKlient();
+		__declspec(dllexport) bool verbinde(unsigned short port, const char* ip); // verbindet mit Server
+		__declspec(dllexport) bool sende(const char* nachricht, int len) override; // sendet zum Server
+		__declspec(dllexport) bool getNachricht(char* nachricht, int len) override; // empfängt Nachricht
+		__declspec(dllexport) int getDownloadBytes(bool reset); // gibt die anzahl von empfangen bytes zurück
+		__declspec(dllexport) int getUploadBytes(bool reset); // gibt die anzahl von versendeter bytes zurück
+		__declspec(dllexport) bool trenne(); // Trennt die Verbindung zum Server
+		// constant 
+		__declspec(dllexport) bool hatNachricht(int zeit); // Wartet eine Zeit Lang auf eine Nachricht
+		__declspec(dllexport) unsigned short getServerPort() const; // gibt den Port des Servers zurück
+		__declspec(dllexport) const char* getServerIp() const; // gibt die Ip des Servers zurück
+	};
 }
 
 #endif

Network/Network.cpp

@@ -10,45 +10,45 @@
 #include <Text.h>
 
 // Starte Netzwerk
-void Network::Start( int maxClients )
+void Network::Start(int maxClients)
 {
 #ifdef WIN32
-    WSADATA lpwd;
-    lpwd.iMaxSockets = maxClients;
-    int fehler = WSAStartup( MAKEWORD( 2, 0 ), &lpwd );
-    if( fehler != 0 )
-        MessageBox( 0, "Win Sock 2.0 konnte nocht gestartet werden.", "Fehler", MB_ICONERROR );
+	WSADATA lpwd;
+	lpwd.iMaxSockets = maxClients;
+	int fehler = WSAStartup(MAKEWORD(2, 0), &lpwd);
+	if (fehler != 0)
+		MessageBox(0, "Win Sock 2.0 konnte nocht gestartet werden.", "Fehler", MB_ICONERROR);
 #else
-    signal( SIGPIPE, SIG_IGN );
+	signal(SIGPIPE, SIG_IGN);
 #endif
-    SSL_library_init();
-    SSL_load_error_strings();
-    OpenSSL_add_ssl_algorithms();
+	SSL_library_init();
+	SSL_load_error_strings();
+	OpenSSL_add_ssl_algorithms();
 }
 
-void Network::getHostName( char *name, int bufferLen )
+void Network::getHostName(char* name, int bufferLen)
 {
-    gethostname( name, bufferLen );
+	gethostname(name, bufferLen);
 }
 
-char *Network::getHostAddresse()
+char* Network::getHostAddresse()
 {
-    char *addresse;
-    char name[ 255 ] = "";
-    getHostName( name, 255 );
-    PHOSTENT hostinfo;
-    hostinfo = gethostbyname( name );
-    if( !hostinfo )
-    {
+	char* addresse;
+	char name[255] = "";
+	getHostName(name, 255);
+	PHOSTENT hostinfo;
+	hostinfo = gethostbyname(name);
+	if (!hostinfo)
+	{
 #ifdef WIN32
-        MessageBox( 0, "Die Ip Addresse konnte nicht ermittelt werden.", "Fehler", MB_ICONERROR );
+		MessageBox(0, "Die Ip Addresse konnte nicht ermittelt werden.", "Fehler", MB_ICONERROR);
 #else
-        std::cout << "Fehler: Die Ip Addresse konnte nicht ermittelt werden.";
+		std::cout << "Fehler: Die Ip Addresse konnte nicht ermittelt werden.";
 #endif
-        return 0;
-    }
-    addresse = inet_ntoa( *(struct in_addr *)*hostinfo->h_addr_list );
-    return addresse;
+		return 0;
+	}
+	addresse = inet_ntoa(*(struct in_addr*)*hostinfo->h_addr_list);
+	return addresse;
 }
 
 
@@ -56,14 +56,14 @@ char *Network::getHostAddresse()
 void Network::Exit()
 {
 #ifdef WIN32
-    WSACleanup();
+	WSACleanup();
 #endif
 }
 
 
-Network::NetworkReader::NetworkReader( Verbindung *v )
+Network::NetworkReader::NetworkReader(Verbindung* v)
 {
-    verbindung = v;
+	verbindung = v;
 }
 
 Network::NetworkReader::~NetworkReader()
@@ -72,49 +72,49 @@ Network::NetworkReader::~NetworkReader()
 //! Ließt aus der Datei
 //! \param bytes Ein Array, der mit Bytes aus der Resource gefüllt werden soll
 //! \param len Wie viele Bytes aus der Resource gelesen werden sollen
-void Network::NetworkReader::lese( char *bytes, int len )
+void Network::NetworkReader::lese(char* bytes, int len)
 {
-    verbindung->getNachricht( bytes, len );
+	verbindung->getNachricht(bytes, len);
 }
 
 //! Ließt die nächste zeile der Resource ein
 //! \return Die gelesene Zeile als Text mit zeilenumbruch
-Framework::Text *Network::NetworkReader::leseZeile()
-{
-    int maxLength = 2048;
-    char *buffer = new char[ maxLength ];
-    char b;
-    int index = 0;
-    do
-    {
-        verbindung->getNachricht( &b, 1 );
-        buffer[ index++ ] = b;
-        if( index == maxLength )
-        {
-            maxLength += 2048;
-            char *tmp = new char[ maxLength ];
-            memcpy( tmp, buffer, (__int64)maxLength - 2048 );
-            delete[] buffer;
-            buffer = tmp;
-        }
-    } while( b != '\n' );
-    buffer[ index ] = 0;
-    Framework::Text *result = new Framework::Text( buffer );
-    delete[] buffer;
-    return result;
+Framework::Text* Network::NetworkReader::leseZeile()
+{
+	int maxLength = 2048;
+	char* buffer = new char[maxLength];
+	char b;
+	int index = 0;
+	do
+	{
+		verbindung->getNachricht(&b, 1);
+		buffer[index++] = b;
+		if (index == maxLength)
+		{
+			maxLength += 2048;
+			char* tmp = new char[maxLength];
+			memcpy(tmp, buffer, (__int64)maxLength - 2048);
+			delete[] buffer;
+			buffer = tmp;
+		}
+	} while (b != '\n');
+	buffer[index] = 0;
+	Framework::Text* result = new Framework::Text(buffer);
+	delete[] buffer;
+	return result;
 }
 
 //! Prüft, ob die Resource vollständig gelesen wurde
 //!  return 1, wenn die Resource vollständig gelesen wurde. 0, sonst
 bool Network::NetworkReader::istEnde() const
 {
-    return 0;
+	return 0;
 }
 
 
-Network::NetworkWriter::NetworkWriter( Verbindung *v )
+Network::NetworkWriter::NetworkWriter(Verbindung* v)
 {
-    verbindung = v;
+	verbindung = v;
 }
 
 Network::NetworkWriter::~NetworkWriter()
@@ -123,83 +123,83 @@ Network::NetworkWriter::~NetworkWriter()
 //! Schreibt in die Resource
 //! \param bytes Ein Array, der die Bytes enthält, welche in die Resource geschrieben werden soll
 //! \param len Wie viele Bytes in die Resource geschrieben werden sollen
-void Network::NetworkWriter::schreibe( const char *bytes, int len )
+void Network::NetworkWriter::schreibe(const char* bytes, int len)
 {
-    verbindung->sende( bytes, len );
+	verbindung->sende(bytes, len);
 }
 
 //! Prüft, ob die Resource vollständig geschrieben wurde
 //!  return 1, wenn die Resource vollständig geschrieben wurde. 0, sonst
 bool Network::NetworkWriter::istEnde() const
 {
-    return 0;
+	return 0;
 }
 
 
-Network::EncryptedNetworkReader::EncryptedNetworkReader( EncryptedVerbindung *v )
+Network::EncryptedNetworkReader::EncryptedNetworkReader(EncryptedVerbindung* v)
 {
-    verbindung = v;
+	verbindung = v;
 }
 
 //! Ließt aus der Datei
 //! \param bytes Ein Array, der mit Bytes aus der Resource gefüllt werden soll
 //! \param len Wie viele Bytes aus der Resource gelesen werden sollen
-void Network::EncryptedNetworkReader::lese( char *bytes, int len )
+void Network::EncryptedNetworkReader::lese(char* bytes, int len)
 {
-    verbindung->getNachrichtEncrypted( bytes, len );
+	verbindung->getNachrichtEncrypted(bytes, len);
 }
 
 //! Ließt die nächste zeile der Resource ein
 //! \return Die gelesene Zeile als Text mit zeilenumbruch
-Framework::Text *Network::EncryptedNetworkReader::leseZeile()
-{
-    int maxLength = 2048;
-    char *buffer = new char[ maxLength ];
-    char b;
-    int index = 0;
-    do
-    {
-        verbindung->getNachrichtEncrypted( &b, 1 );
-        buffer[ index++ ] = b;
-        if( index == maxLength )
-        {
-            maxLength += 2048;
-            char *tmp = new char[ maxLength ];
-            memcpy( tmp, buffer, (__int64)maxLength - 2048 );
-            delete[] buffer;
-            buffer = tmp;
-        }
-    } while( b != '\n' );
-    buffer[ index ] = 0;
-    Framework::Text *result = new Framework::Text( buffer );
-    delete[] buffer;
-    return result;
+Framework::Text* Network::EncryptedNetworkReader::leseZeile()
+{
+	int maxLength = 2048;
+	char* buffer = new char[maxLength];
+	char b;
+	int index = 0;
+	do
+	{
+		verbindung->getNachrichtEncrypted(&b, 1);
+		buffer[index++] = b;
+		if (index == maxLength)
+		{
+			maxLength += 2048;
+			char* tmp = new char[maxLength];
+			memcpy(tmp, buffer, (__int64)maxLength - 2048);
+			delete[] buffer;
+			buffer = tmp;
+		}
+	} while (b != '\n');
+	buffer[index] = 0;
+	Framework::Text* result = new Framework::Text(buffer);
+	delete[] buffer;
+	return result;
 }
 
 //! Prüft, ob die Resource vollständig gelesen wurde
 //!  return 1, wenn die Resource vollständig gelesen wurde. 0, sonst
 bool Network::EncryptedNetworkReader::istEnde() const
 {
-    return 0;
+	return 0;
 }
 
 
-Network::EncryptedNetworkWriter::EncryptedNetworkWriter( EncryptedVerbindung *v )
+Network::EncryptedNetworkWriter::EncryptedNetworkWriter(EncryptedVerbindung* v)
 {
-    verbindung = v;
+	verbindung = v;
 }
 
 //! Schreibt in die Resource
 //! \param bytes Ein Array, der die Bytes enthält, welche in die Resource geschrieben werden soll
 //! \param len Wie viele Bytes in die Resource geschrieben werden sollen
-void Network::EncryptedNetworkWriter::schreibe( const char *bytes, int len )
+void Network::EncryptedNetworkWriter::schreibe(const char* bytes, int len)
 {
-    verbindung->sendeEncrypted( bytes, len );
+	verbindung->sendeEncrypted(bytes, len);
 }
 
 //! Prüft, ob die Resource vollständig geschrieben wurde
 //!  return 1, wenn die Resource vollständig geschrieben wurde. 0, sonst
 bool Network::EncryptedNetworkWriter::istEnde() const
 {
-    return 0;
+	return 0;
 }

Network/Network.h

@@ -37,102 +37,102 @@
 
 namespace Framework
 {
-    class Text;
+	class Text;
 }
 
 namespace Network
 {
-    __declspec( dllexport ) void Start( int maxClients );
-    __declspec( dllexport ) void getHostName( char *name, int bufferLen );
-    __declspec( dllexport ) char *getHostAddresse();
-    __declspec( dllexport ) void Exit();
+	__declspec(dllexport) void Start(int maxClients);
+	__declspec(dllexport) void getHostName(char* name, int bufferLen);
+	__declspec(dllexport) char* getHostAddresse();
+	__declspec(dllexport) void Exit();
 
 
-    class Verbindung
-    {
-    public:
-        virtual bool sende( const char *nachricht, int len ) = 0; // sendet Nachricht
-        virtual bool getNachricht( char *nachricht, int len ) = 0; // empfängt Nachricht
-    };
+	class Verbindung
+	{
+	public:
+		virtual bool sende(const char* nachricht, int len) = 0; // sendet Nachricht
+		virtual bool getNachricht(char* nachricht, int len) = 0; // empfängt Nachricht
+	};
 
-    class EncryptedVerbindung : public Verbindung
-    {
-    public:
-        virtual bool sendeEncrypted( const char *nachricht, int len ) = 0; // sendet Nachricht
-        virtual bool getNachrichtEncrypted( char *nachricht, int len ) = 0; // empfängt Nachricht
-    };
+	class EncryptedVerbindung : public Verbindung
+	{
+	public:
+		virtual bool sendeEncrypted(const char* nachricht, int len) = 0; // sendet Nachricht
+		virtual bool getNachrichtEncrypted(char* nachricht, int len) = 0; // empfängt Nachricht
+	};
 
-    class NetworkReader : public Framework::StreamReader
-    {
-    private:
-        Verbindung *verbindung;
+	class NetworkReader : public Framework::StreamReader
+	{
+	private:
+		Verbindung* verbindung;
 
-    public:
-        __declspec( dllexport ) NetworkReader( Verbindung *v );
-        __declspec( dllexport ) virtual ~NetworkReader();
-        //! Ließt aus der Datei
-        //! \param bytes Ein Array, der mit Bytes aus der Resource gefüllt werden soll
-        //! \param len Wie viele Bytes aus der Resource gelesen werden sollen
-        __declspec( dllexport ) void lese( char *bytes, int len ) override;
-        //! Ließt die nächste zeile der Resource ein
-        //! \return Die gelesene Zeile als Text mit zeilenumbruch
-        __declspec( dllexport ) Framework::Text *leseZeile() override;
-        //! Prüft, ob die Resource vollständig gelesen wurde
-        //!  return 1, wenn die Resource vollständig gelesen wurde. 0, sonst
-        __declspec( dllexport ) bool istEnde() const override;
-    };
+	public:
+		__declspec(dllexport) NetworkReader(Verbindung* v);
+		__declspec(dllexport) virtual ~NetworkReader();
+		//! Ließt aus der Datei
+		//! \param bytes Ein Array, der mit Bytes aus der Resource gefüllt werden soll
+		//! \param len Wie viele Bytes aus der Resource gelesen werden sollen
+		__declspec(dllexport) void lese(char* bytes, int len) override;
+		//! Ließt die nächste zeile der Resource ein
+		//! \return Die gelesene Zeile als Text mit zeilenumbruch
+		__declspec(dllexport) Framework::Text* leseZeile() override;
+		//! Prüft, ob die Resource vollständig gelesen wurde
+		//!  return 1, wenn die Resource vollständig gelesen wurde. 0, sonst
+		__declspec(dllexport) bool istEnde() const override;
+	};
 
-    class NetworkWriter : public Framework::StreamWriter
-    {
-    private:
-        Verbindung *verbindung;
+	class NetworkWriter : public Framework::StreamWriter
+	{
+	private:
+		Verbindung* verbindung;
 
-    public:
-        __declspec( dllexport ) NetworkWriter( Verbindung *v );
-        __declspec( dllexport ) virtual ~NetworkWriter();
-        //! Schreibt in die Resource
-        //! \param bytes Ein Array, der die Bytes enthält, welche in die Resource geschrieben werden soll
-        //! \param len Wie viele Bytes in die Resource geschrieben werden sollen
-        __declspec( dllexport ) void schreibe( const char *bytes, int len ) override;
-        //! Prüft, ob die Resource vollständig geschrieben wurde
-        //!  return 1, wenn die Resource vollständig geschrieben wurde. 0, sonst
-        __declspec( dllexport ) bool istEnde() const override;
-    };
+	public:
+		__declspec(dllexport) NetworkWriter(Verbindung* v);
+		__declspec(dllexport) virtual ~NetworkWriter();
+		//! Schreibt in die Resource
+		//! \param bytes Ein Array, der die Bytes enthält, welche in die Resource geschrieben werden soll
+		//! \param len Wie viele Bytes in die Resource geschrieben werden sollen
+		__declspec(dllexport) void schreibe(const char* bytes, int len) override;
+		//! Prüft, ob die Resource vollständig geschrieben wurde
+		//!  return 1, wenn die Resource vollständig geschrieben wurde. 0, sonst
+		__declspec(dllexport) bool istEnde() const override;
+	};
 
-    class EncryptedNetworkReader : public Framework::StreamReader
-    {
-    private:
-        EncryptedVerbindung *verbindung;
+	class EncryptedNetworkReader : public Framework::StreamReader
+	{
+	private:
+		EncryptedVerbindung* verbindung;
 
-    public:
-        __declspec( dllexport ) EncryptedNetworkReader( EncryptedVerbindung *v );
-        //! Ließt aus der Datei
-        //! \param bytes Ein Array, der mit Bytes aus der Resource gefüllt werden soll
-        //! \param len Wie viele Bytes aus der Resource gelesen werden sollen
-        __declspec( dllexport ) void lese( char *bytes, int len ) override;
-        //! Ließt die nächste zeile der Resource ein
-        //! \return Die gelesene Zeile als Text mit zeilenumbruch
-        __declspec( dllexport ) Framework::Text *leseZeile() override;
-        //! Prüft, ob die Resource vollständig gelesen wurde
-        //!  return 1, wenn die Resource vollständig gelesen wurde. 0, sonst
-        __declspec( dllexport ) bool istEnde() const override;
-    };
+	public:
+		__declspec(dllexport) EncryptedNetworkReader(EncryptedVerbindung* v);
+		//! Ließt aus der Datei
+		//! \param bytes Ein Array, der mit Bytes aus der Resource gefüllt werden soll
+		//! \param len Wie viele Bytes aus der Resource gelesen werden sollen
+		__declspec(dllexport) void lese(char* bytes, int len) override;
+		//! Ließt die nächste zeile der Resource ein
+		//! \return Die gelesene Zeile als Text mit zeilenumbruch
+		__declspec(dllexport) Framework::Text* leseZeile() override;
+		//! Prüft, ob die Resource vollständig gelesen wurde
+		//!  return 1, wenn die Resource vollständig gelesen wurde. 0, sonst
+		__declspec(dllexport) bool istEnde() const override;
+	};
 
-    class EncryptedNetworkWriter : public Framework::StreamWriter
-    {
-    private:
-        EncryptedVerbindung *verbindung;
+	class EncryptedNetworkWriter : public Framework::StreamWriter
+	{
+	private:
+		EncryptedVerbindung* verbindung;
 
-    public:
-        __declspec( dllexport ) EncryptedNetworkWriter( EncryptedVerbindung *v );
-        //! Schreibt in die Resource
-        //! \param bytes Ein Array, der die Bytes enthält, welche in die Resource geschrieben werden soll
-        //! \param len Wie viele Bytes in die Resource geschrieben werden sollen
-        __declspec( dllexport ) void schreibe( const char *bytes, int len ) override;
-        //! Prüft, ob die Resource vollständig geschrieben wurde
-        //!  return 1, wenn die Resource vollständig geschrieben wurde. 0, sonst
-        __declspec( dllexport ) bool istEnde() const override;
-    };
+	public:
+		__declspec(dllexport) EncryptedNetworkWriter(EncryptedVerbindung* v);
+		//! Schreibt in die Resource
+		//! \param bytes Ein Array, der die Bytes enthält, welche in die Resource geschrieben werden soll
+		//! \param len Wie viele Bytes in die Resource geschrieben werden sollen
+		__declspec(dllexport) void schreibe(const char* bytes, int len) override;
+		//! Prüft, ob die Resource vollständig geschrieben wurde
+		//!  return 1, wenn die Resource vollständig geschrieben wurde. 0, sonst
+		__declspec(dllexport) bool istEnde() const override;
+	};
 }
 
 #endif

Network/Server.cpp

@@ -13,595 +13,595 @@ using namespace Network;
 // Inhalt der Server Klasse aus Server.h
 // Konstruktor 
 Server::Server()
-    : ReferenceCounter()
+	: ReferenceCounter()
 {
-    sock = 0;
-    memset( &addresse, 0, sizeof( addresse ) ); // Adresse setzen
-    addresse.sin_family = AF_INET;
-    addresse.sin_addr.s_addr = ADDR_ANY;
-    klients = 0;
+	sock = 0;
+	memset(&addresse, 0, sizeof(addresse)); // Adresse setzen
+	addresse.sin_family = AF_INET;
+	addresse.sin_addr.s_addr = ADDR_ANY;
+	klients = 0;
 }
 
 // Destruktor 
 Server::~Server()
 {
-    trenne();
+	trenne();
 }
 
 // nicht constant 
-bool Server::verbinde( unsigned short port, int warteschlangenLen ) // Öffnet das Socket
-{
-    sock = socket( AF_INET, SOCK_STREAM, 0 ); // Socket erstellen
-    addresse.sin_port = htons( port ); // port setzen
-    if( bind( sock, (struct sockaddr*)&addresse, sizeof( addresse ) ) == -1 ) // socket öffnen
-    {
-        trenne();
-        return 0; // Fehler
-    }
-    if( listen( sock, warteschlangenLen ) == -1 ) // Klients annehmen
-    {
-        trenne();
-        return 0; // Fehler
-    }
-    return 1;
+bool Server::verbinde(unsigned short port, int warteschlangenLen) // Öffnet das Socket
+{
+	sock = socket(AF_INET, SOCK_STREAM, 0); // Socket erstellen
+	addresse.sin_port = htons(port); // port setzen
+	if (bind(sock, (struct sockaddr*)&addresse, sizeof(addresse)) == -1) // socket öffnen
+	{
+		trenne();
+		return 0; // Fehler
+	}
+	if (listen(sock, warteschlangenLen) == -1) // Klients annehmen
+	{
+		trenne();
+		return 0; // Fehler
+	}
+	return 1;
 }
 
 SKlient* Server::getKlient() // nimmt Klient an
 {
-    if( !sock )
-        return 0;
-    sockaddr_in client;
-    int len = sizeof( addresse );
+	if (!sock)
+		return 0;
+	sockaddr_in client;
+	int len = sizeof(addresse);
 #ifdef WIN32
-    SOCKET cls = accept( sock, (sockaddr*)&client, &len ); // Klient empfangen
-    if( cls == INVALID_SOCKET )
-    {
-        trenne();
-        return 0;
-    }
+	SOCKET cls = accept(sock, (sockaddr*)&client, &len); // Klient empfangen
+	if (cls == INVALID_SOCKET)
+	{
+		trenne();
+		return 0;
+	}
 #else
-    SOCKET cls = accept( sock, (sockaddr*)&client, (socklen_t*)&len ); // Klient empfangen
-    if( !cls )
-    {
-        if( errno == ECONNABORTED || errno == EBADF )
-            trenne();
-        return 0;
-    }
+	SOCKET cls = accept(sock, (sockaddr*)&client, (socklen_t*)&len); // Klient empfangen
+	if (!cls)
+	{
+		if (errno == ECONNABORTED || errno == EBADF)
+			trenne();
+		return 0;
+	}
 #endif
-    client.sin_port = addresse.sin_port;
-    klients++;
-    return new SKlient( client, cls ); // Klient Handle Klasse zurückgeben
+	client.sin_port = addresse.sin_port;
+	klients++;
+	return new SKlient(client, cls); // Klient Handle Klasse zurückgeben
 }
 
-int Server::getKlients( bool reset ) // gibt die Anzahl der Klients zurück
+int Server::getKlients(bool reset) // gibt die Anzahl der Klients zurück
 {
-    int ret = klients;
-    if( reset )
-        klients = 0;
-    return ret;
+	int ret = klients;
+	if (reset)
+		klients = 0;
+	return ret;
 }
 
 bool Server::trenne() // beendet den Server
 {
-    if( !sock )
-        return 1;
-    if( closesocket( sock ) < 0 ) // socket schließen
-        return 0;
-    sock = 0;
-    return 1;
+	if (!sock)
+		return 1;
+	if (closesocket(sock) < 0) // socket schließen
+		return 0;
+	sock = 0;
+	return 1;
 }
 
 // constant
 unsigned short Server::getPort() const // gibt den Port zurück
 {
-    return htons( addresse.sin_port );
+	return htons(addresse.sin_port);
 }
 
 bool Server::isConnected() const // giebt 1 zurück, falls der Server verbunden ist
 {
-    return sock != 0;
+	return sock != 0;
 }
 
 // Inhalt der SKlient Klasse aus Server.h
 // Konstruktor 
-SKlient::SKlient( sockaddr_in addresse, SOCKET sock )
-    : ReferenceCounter()
+SKlient::SKlient(sockaddr_in addresse, SOCKET sock)
+	: ReferenceCounter()
 {
-    clientAddr = addresse;
-    this->sock = sock;
-    downStreamBytes = 0;
-    upStreamBytes = 0;
-    sendeKey = 0;
-    empfangKey = 0;
+	clientAddr = addresse;
+	this->sock = sock;
+	downStreamBytes = 0;
+	upStreamBytes = 0;
+	sendeKey = 0;
+	empfangKey = 0;
 }
 
 // Destruktor 
 SKlient::~SKlient()
 {
-    trenne();
-    if( sendeKey )
-        sendeKey->release();
-    if( empfangKey )
-        empfangKey->release();
+	trenne();
+	if (sendeKey)
+		sendeKey->release();
+	if (empfangKey)
+		empfangKey->release();
 }
 
 // nicht constant 
-void SKlient::setEmpfangTimeout( int miliseconds ) // Setzt ein timeout fürs empfangen von daten
+void SKlient::setEmpfangTimeout(int miliseconds) // Setzt ein timeout fürs empfangen von daten
 {
 #ifdef WIN32
-    DWORD timeout = miliseconds;
-    setsockopt( sock, SOL_SOCKET, SO_RCVTIMEO, (const char*)&timeout, sizeof timeout );
+	DWORD timeout = miliseconds;
+	setsockopt(sock, SOL_SOCKET, SO_RCVTIMEO, (const char*)&timeout, sizeof timeout);
 #else
-    struct timeval tv;
-    tv.tv_sec = miliseconds / 1000;
-    tv.tv_usec = (miliseconds % 1000) * 1000;
-    setsockopt( sock, SOL_SOCKET, SO_RCVTIMEO, (const char*)&tv, sizeof tv );
+	struct timeval tv;
+	tv.tv_sec = miliseconds / 1000;
+	tv.tv_usec = (miliseconds % 1000) * 1000;
+	setsockopt(sock, SOL_SOCKET, SO_RCVTIMEO, (const char*)&tv, sizeof tv);
 #endif
 }
 
-void SKlient::setSendeKeyZ( Encryption::Key* key ) // Setzt den Key fürs Senden
+void SKlient::setSendeKeyZ(Encryption::Key* key) // Setzt den Key fürs Senden
 {
-    if( sendeKey )
-        sendeKey->release();
-    sendeKey = key;
+	if (sendeKey)
+		sendeKey->release();
+	sendeKey = key;
 }
 
-void SKlient::setEmpfangKeyZ( Encryption::Key* key ) // Setzt den Key fürs Empfangen
+void SKlient::setEmpfangKeyZ(Encryption::Key* key) // Setzt den Key fürs Empfangen
 {
-    if( empfangKey )
-        empfangKey->release();
-    empfangKey = key;
+	if (empfangKey)
+		empfangKey->release();
+	empfangKey = key;
 }
 
-void SKlient::setSendeKey( char* key, int len ) // Setzt den Key fürs Senden
+void SKlient::setSendeKey(const char* key, int len) // Setzt den Key fürs Senden
 {
-    if( !sendeKey )
-        sendeKey = new Encryption::Key();
-    sendeKey->setKey( key, len );
+	if (!sendeKey)
+		sendeKey = new Encryption::Key();
+	sendeKey->setKey(key, len);
 }
 
-void SKlient::setEmpfangKey( char* key, int len ) // Setzt den Key fürs Empfangen
+void SKlient::setEmpfangKey(const char* key, int len) // Setzt den Key fürs Empfangen
 {
-    if( !empfangKey )
-        empfangKey = new Encryption::Key();
-    empfangKey->setKey( key, len );
+	if (!empfangKey)
+		empfangKey = new Encryption::Key();
+	empfangKey->setKey(key, len);
 }
 
-bool SKlient::sende( const char* nachricht, int len ) // sendet zum Klient
+bool SKlient::sende(const char* nachricht, int len) // sendet zum Klient
 {
-    if( !sock )
-        return 0;
-    int ll = 0;
-    while( len > 0 )
-    {
+	if (!sock)
+		return 0;
+	int ll = 0;
+	while (len > 0)
+	{
 #ifdef WIN32
-        int l = send( sock, nachricht + ll, len, 0 );
+		int l = send(sock, nachricht + ll, len, 0);
 #else
-        int l = (int)send( sock, nachricht + ll, len, MSG_NOSIGNAL );
+		int l = (int)send(sock, nachricht + ll, len, MSG_NOSIGNAL);
 #endif
-        if( l <= 0 )
-            return 0; // Fehler
-        len -= l;
-        ll += l;
-    }
-    upStreamBytes += ll;
-    return 1;
-}
-
-bool SKlient::getNachricht( char* nachricht, int len ) // empfängt Nachricht von Klient
-{
-    if( !sock )
-        return 0;
-    int ll = 0;
-    while( len > 0 )
-    {
-        int l = (int)recv( sock, nachricht + ll, len, MSG_WAITALL );
-        if( l <= 0 )
-            return 0; // Fehler
-        len -= l;
-        ll += l;
-    }
-    downStreamBytes += ll;
-    return 1;
-}
-
-bool SKlient::sendeEncrypted( const char* nachricht, int len ) // sendet zum Server
-{
-    if( !sendeKey )
-        return sende( nachricht, len );
-    Encryption::Bytes* n = new Encryption::Bytes( nachricht, len );
-    sendeKey->codieren( dynamic_cast<Encryption::Bytes*>(n->getThis()) ); int ll = 0;
-    while( len > 0 )
-    {
+		if (l <= 0)
+			return 0; // Fehler
+		len -= l;
+		ll += l;
+	}
+	upStreamBytes += ll;
+	return 1;
+}
+
+bool SKlient::getNachricht(char* nachricht, int len) // empfängt Nachricht von Klient
+{
+	if (!sock)
+		return 0;
+	int ll = 0;
+	while (len > 0)
+	{
+		int l = (int)recv(sock, nachricht + ll, len, MSG_WAITALL);
+		if (l <= 0)
+			return 0; // Fehler
+		len -= l;
+		ll += l;
+	}
+	downStreamBytes += ll;
+	return 1;
+}
+
+bool SKlient::sendeEncrypted(const char* nachricht, int len) // sendet zum Server
+{
+	if (!sendeKey)
+		return sende(nachricht, len);
+	Encryption::Bytes* n = new Encryption::Bytes(nachricht, len);
+	sendeKey->codieren(dynamic_cast<Encryption::Bytes*>(n->getThis())); int ll = 0;
+	while (len > 0)
+	{
 #ifdef WIN32
-        int l = send( sock, n->getBytes() + ll, len, 0 );
+		int l = send(sock, n->getBytes() + ll, len, 0);
 #else
-        int l = (int)send( sock, n->getBytes() + ll, len, MSG_NOSIGNAL );
+		int l = (int)send(sock, n->getBytes() + ll, len, MSG_NOSIGNAL);
 #endif
-        if( l <= 0 )
-        {
-            n->release();
-            return 0; // Fehler
-        }
-        len -= l;
-        ll += l;
-    }
-    upStreamBytes += ll;
-    n->release();
-    return 1;
-}
-
-bool SKlient::getNachrichtEncrypted( char* nachricht, int len ) // empfängt Nachricht
-{
-    if( !empfangKey )
-        return getNachricht( nachricht, len );
-    int ll = 0;
-    while( len > 0 )
-    {
-        int l = (int)recv( sock, nachricht + ll, len, MSG_WAITALL );
-        if( l <= 0 )
-            return 0; // Fehler
-        len -= l;
-        ll += l;
-    }
-    Encryption::Bytes* n = new Encryption::Bytes();
-    n->setBytesZ( nachricht, ll );
-    empfangKey->decodieren( n );
-    downStreamBytes += ll;
-    return 1;
-}
-
-int SKlient::getDownloadBytes( bool reset ) // gibt die anzahl von empfangen bytes zurück
-{
-    int ret = downStreamBytes;
-    if( reset )
-        downStreamBytes = 0;
-    return ret;
-}
-
-int SKlient::getUploadBytes( bool reset ) // gibt die anzahl von versendeter bytes zurück
-{
-    int ret = upStreamBytes;
-    if( reset )
-        upStreamBytes = 0;
-    return ret;
+		if (l <= 0)
+		{
+			n->release();
+			return 0; // Fehler
+		}
+		len -= l;
+		ll += l;
+	}
+	upStreamBytes += ll;
+	n->release();
+	return 1;
+}
+
+bool SKlient::getNachrichtEncrypted(char* nachricht, int len) // empfängt Nachricht
+{
+	if (!empfangKey)
+		return getNachricht(nachricht, len);
+	int ll = 0;
+	while (len > 0)
+	{
+		int l = (int)recv(sock, nachricht + ll, len, MSG_WAITALL);
+		if (l <= 0)
+			return 0; // Fehler
+		len -= l;
+		ll += l;
+	}
+	Encryption::Bytes* n = new Encryption::Bytes();
+	n->setBytesZ(nachricht, ll);
+	empfangKey->decodieren(n);
+	downStreamBytes += ll;
+	return 1;
+}
+
+int SKlient::getDownloadBytes(bool reset) // gibt die anzahl von empfangen bytes zurück
+{
+	int ret = downStreamBytes;
+	if (reset)
+		downStreamBytes = 0;
+	return ret;
+}
+
+int SKlient::getUploadBytes(bool reset) // gibt die anzahl von versendeter bytes zurück
+{
+	int ret = upStreamBytes;
+	if (reset)
+		upStreamBytes = 0;
+	return ret;
 }
 
 bool SKlient::trenne() // trennt die Verbindung zum Klient
 {
-    if( !sock )
-        return 0;
-    if( closesocket( sock ) < 0 ) // trennen
-        return 0;
-    sock = 0;
-    return 1;
+	if (!sock)
+		return 0;
+	if (closesocket(sock) < 0) // trennen
+		return 0;
+	sock = 0;
+	return 1;
 }
 
 // constant 
-bool SKlient::hatNachricht( int zeit ) const // Wartet eine Zeit Lang auf eine Nachricht
+bool SKlient::hatNachricht(int zeit) const // Wartet eine Zeit Lang auf eine Nachricht
 {
-    fd_set set;
-    FD_ZERO( &set );
-    FD_SET( sock, &set );
-    timeval time = { zeit / 1000, zeit };
-    return select( 0, &set, 0, 0, &time ) == 1;
+	fd_set set;
+	FD_ZERO(&set);
+	FD_SET(sock, &set);
+	timeval time = { zeit / 1000, zeit };
+	return select(0, &set, 0, 0, &time) == 1;
 }
 
 unsigned short SKlient::getPort() const // gibt den Port zurück
 {
-    return htons( clientAddr.sin_port );
+	return htons(clientAddr.sin_port);
 }
 
 const char* SKlient::getIp() const // gibt die Ip des Klients zurück
 {
-    return inet_ntoa( clientAddr.sin_addr );
+	return inet_ntoa(clientAddr.sin_addr);
 }
 
-int pem_passwd_cb( char* buf, int size, int rwflag, void* userdata )
+int pem_passwd_cb(char* buf, int size, int rwflag, void* userdata)
 {
-    const char* passw = ((Text*)userdata)->getText();
-    memcpy( buf, passw, MIN( (unsigned int)size, strlen( passw ) + 1 ) );
-    return (int)strlen( buf );
+	const char* passw = ((Text*)userdata)->getText();
+	memcpy(buf, passw, MIN((unsigned int)size, strlen(passw) + 1));
+	return (int)strlen(buf);
 }
 
-bool SSLErrorCheck( int result, SSL* ssl, const char* action )
+bool SSLErrorCheck(int result, SSL* ssl, const char* action)
 {
-    if( result <= 0 )
-    {
-        std::cout << "ERROR: '" << action << "' returned error code: " << SSL_get_error( ssl, result ) << "\n";
-        std::cout.flush();
-        return 0;
-    }
-    return 1;
+	if (result <= 0)
+	{
+		std::cout << "ERROR: '" << action << "' returned error code: " << SSL_get_error(ssl, result) << "\n";
+		std::cout.flush();
+		return 0;
+	}
+	return 1;
 }
 
-bool SSLErrorCheck( __int64 result, const char* action )
+bool SSLErrorCheck(__int64 result, const char* action)
 {
-    if( result <= 0 )
-    {
-        unsigned long error = ERR_get_error();
-        std::cout << "ERROR: '" << action << "' returned " << result << " error code: " << error << "(" << ERR_reason_error_string( error ) << ")\n";
-        std::cout.flush();
-        return 0;
-    }
-    return 1;
+	if (result <= 0)
+	{
+		unsigned long error = ERR_get_error();
+		std::cout << "ERROR: '" << action << "' returned " << result << " error code: " << error << "(" << ERR_reason_error_string(error) << ")\n";
+		std::cout.flush();
+		return 0;
+	}
+	return 1;
 }
 
 bool SKlient::waitForNextMessage() const // wartet bis es etwas zu empfangen gibt
 {
-    char c;
-    int l = (int)recv( sock, &c, 1, MSG_WAITALL | MSG_PEEK );
-    if( l <= 0 )
-        return 0; // Fehler
-    return 1;
+	char c;
+	int l = (int)recv(sock, &c, 1, MSG_WAITALL | MSG_PEEK);
+	if (l <= 0)
+		return 0; // Fehler
+	return 1;
 }
 
 
 // Inhalt der SSLServer Klasse
 // Konstruktor 
 SSLServer::SSLServer()
-    : ReferenceCounter()
-{
-    s = 0;
-    const SSL_METHOD* method = TLS_server_method();
-    ctx = SSL_CTX_new( method );
-    SSLErrorCheck( SSL_CTX_set_min_proto_version( ctx, TLS1_2_VERSION ), "SSL_CTX_set_min_proto_version" );
-    SSLErrorCheck( SSL_CTX_set_max_proto_version( ctx, TLS1_3_VERSION ), "SSL_CTX_set_max_proto_version" );
-    SSL_CTX_set_verify( ctx, SSL_VERIFY_NONE, 0 );
-    SSL_CTX_set_default_passwd_cb( ctx, pem_passwd_cb );
-    passw = new Text();
-    SSL_CTX_set_default_passwd_cb_userdata( ctx, passw );
-    addr.sin_family = AF_INET;
-    addr.sin_addr.s_addr = htonl( INADDR_ANY );
-    klients = 0;
+	: ReferenceCounter()
+{
+	s = 0;
+	const SSL_METHOD* method = TLS_server_method();
+	ctx = SSL_CTX_new(method);
+	SSLErrorCheck(SSL_CTX_set_min_proto_version(ctx, TLS1_2_VERSION), "SSL_CTX_set_min_proto_version");
+	SSLErrorCheck(SSL_CTX_set_max_proto_version(ctx, TLS1_3_VERSION), "SSL_CTX_set_max_proto_version");
+	SSL_CTX_set_verify(ctx, SSL_VERIFY_NONE, 0);
+	SSL_CTX_set_default_passwd_cb(ctx, pem_passwd_cb);
+	passw = new Text();
+	SSL_CTX_set_default_passwd_cb_userdata(ctx, passw);
+	addr.sin_family = AF_INET;
+	addr.sin_addr.s_addr = htonl(INADDR_ANY);
+	klients = 0;
 }
 
 // Destruktor 
 SSLServer::~SSLServer()
 {
-    trenne();
-    SSL_CTX_free( ctx );
-    passw->release();
+	trenne();
+	SSL_CTX_free(ctx);
+	passw->release();
 #ifdef WIN32
-    OPENSSL_thread_stop();
+	OPENSSL_thread_stop();
 #endif
 }
 
 // nicht constant 
 // Setzt den Pfad zur Datei, in dem das Certifikat gespeichert ist
-bool SSLServer::setCertificateFile( const char* file )
+bool SSLServer::setCertificateFile(const char* file)
 {
-    return SSLErrorCheck( SSL_CTX_use_certificate_file( ctx, file, SSL_FILETYPE_PEM ), "SSL_CTX_use_certificate_file" );
+	return SSLErrorCheck(SSL_CTX_use_certificate_file(ctx, file, SSL_FILETYPE_PEM), "SSL_CTX_use_certificate_file");
 }
 
 // Setzt den Pfad zur Datei, in dem der private Schlüssel gespeichert ist
-bool SSLServer::setPrivateKeyFile( const char* file )
+bool SSLServer::setPrivateKeyFile(const char* file)
 {
-    return SSLErrorCheck( SSL_CTX_use_PrivateKey_file( ctx, file, SSL_FILETYPE_PEM ), "SSL_CTX_use_PrivateKey_file" );
+	return SSLErrorCheck(SSL_CTX_use_PrivateKey_file(ctx, file, SSL_FILETYPE_PEM), "SSL_CTX_use_PrivateKey_file");
 }
 
 // setzt das passwort des private keys (muss vor setPrivateKeyFile aufgerufen werden)
-void SSLServer::setPrivateKeyPassword( const char* password )
+void SSLServer::setPrivateKeyPassword(const char* password)
 {
-    passw->setText( password );
+	passw->setText(password);
 }
 
 // Öffnet das Socket
-bool SSLServer::verbinde( unsigned short port, int warteschlangenLen )
-{
-    addr.sin_port = htons( port );
-    s = socket( AF_INET, SOCK_STREAM, 0 );
-    if( s < 0 )
-    {
-        s = 0;
-        return 0;
-    }
-    if( bind( s, (struct sockaddr*)&addr, sizeof( addr ) ) < 0 )
-    {
-        trenne();
-        return 0;
-    }
-    if( listen( s, warteschlangenLen ) < 0 )
-    {
-        trenne();
-        return 0;
-    }
-    return 1;
+bool SSLServer::verbinde(unsigned short port, int warteschlangenLen)
+{
+	addr.sin_port = htons(port);
+	s = socket(AF_INET, SOCK_STREAM, 0);
+	if (s < 0)
+	{
+		s = 0;
+		return 0;
+	}
+	if (bind(s, (struct sockaddr*)&addr, sizeof(addr)) < 0)
+	{
+		trenne();
+		return 0;
+	}
+	if (listen(s, warteschlangenLen) < 0)
+	{
+		trenne();
+		return 0;
+	}
+	return 1;
 }
 
 // nimmt Klient an
 SSLSKlient* SSLServer::getKlient()
 {
-    if( !s )
-        return 0;
-    int len = sizeof( addr );
-    struct sockaddr_in addr;
+	if (!s)
+		return 0;
+	int len = sizeof(addr);
+	struct sockaddr_in addr;
 #ifdef WIN32
-    SOCKET client = accept( s, (struct sockaddr*)&addr, &len );
-    if( client == INVALID_SOCKET )
-    {
-        trenne();
-        return 0;
-    }
+	SOCKET client = accept(s, (struct sockaddr*)&addr, &len);
+	if (client == INVALID_SOCKET)
+	{
+		trenne();
+		return 0;
+	}
 #else
-    SOCKET client = accept( s, (sockaddr*)&addr, (socklen_t*)&len ); // Klient empfangen
-    if( !client )
-    {
-        if( errno == ECONNABORTED || errno == EBADF )
-            trenne();
-        return 0;
-    }
+	SOCKET client = accept(s, (sockaddr*)&addr, (socklen_t*)&len); // Klient empfangen
+	if (!client)
+	{
+		if (errno == ECONNABORTED || errno == EBADF)
+			trenne();
+		return 0;
+	}
 #endif
-    addr.sin_port = this->addr.sin_port;
-    SSL* ssl = SSL_new( ctx );
-    if( ssl == 0 && !SSLErrorCheck( 0, "SSL_new" ) )
-    {
-        closesocket( client );
-        return 0;
-    }
-    if( !SSLErrorCheck( SSL_set_fd( ssl, (int)client ), ssl, "SSL_set_fd" ) )
-    {
-        SSL_free( ssl );
-        closesocket( client );
-        return 0;
-    }
-    if( !SSLErrorCheck( SSL_accept( ssl ), ssl, "SSL_accept" ) )
-    {
-        SSL_free( ssl );
-        closesocket( client );
-        return 0;
-    }
-    klients++;
-    return new SSLSKlient( addr, ssl, client );
+	addr.sin_port = this->addr.sin_port;
+	SSL* ssl = SSL_new(ctx);
+	if (ssl == 0 && !SSLErrorCheck(0, "SSL_new"))
+	{
+		closesocket(client);
+		return 0;
+	}
+	if (!SSLErrorCheck(SSL_set_fd(ssl, (int)client), ssl, "SSL_set_fd"))
+	{
+		SSL_free(ssl);
+		closesocket(client);
+		return 0;
+	}
+	if (!SSLErrorCheck(SSL_accept(ssl), ssl, "SSL_accept"))
+	{
+		SSL_free(ssl);
+		closesocket(client);
+		return 0;
+	}
+	klients++;
+	return new SSLSKlient(addr, ssl, client);
 }
 
 // gibt die Anzahl der Klients zurück
-int SSLServer::getKlients( bool reset )
+int SSLServer::getKlients(bool reset)
 {
-    int ret = klients;
-    if( reset )
-        klients = 0;
-    return ret;
+	int ret = klients;
+	if (reset)
+		klients = 0;
+	return ret;
 }
 
 // beendet den Server
 bool SSLServer::trenne()
 {
-    if( !s )
-        return 1;
-    if( closesocket( s ) < 0 ) // socket schließen
-        return 0;
-    s = 0;
-    return 1;
+	if (!s)
+		return 1;
+	if (closesocket(s) < 0) // socket schließen
+		return 0;
+	s = 0;
+	return 1;
 }
 
 // constant
 // gibt den Port zurück
 unsigned short SSLServer::getPort() const
 {
-    return htons( addr.sin_port );
+	return htons(addr.sin_port);
 }
 
 // giebt 1 zurück, falls der Server verbunden ist
 bool SSLServer::isConnected() const
 {
-    return s != 0;
+	return s != 0;
 }
 
 
 // Inhalt der SSLSKlient Klasse
 // Konstruktor 
-SSLSKlient::SSLSKlient( sockaddr_in client, SSL* ssl, SOCKET s )
-    : ReferenceCounter()
+SSLSKlient::SSLSKlient(sockaddr_in client, SSL* ssl, SOCKET s)
+	: ReferenceCounter()
 {
-    this->s = s;
-    clientAddr = client;
-    this->ssl = ssl;
-    downStreamBytes = 0;
-    upStreamBytes = 0;
+	this->s = s;
+	clientAddr = client;
+	this->ssl = ssl;
+	downStreamBytes = 0;
+	upStreamBytes = 0;
 }
 
 // Destruktor 
 SSLSKlient::~SSLSKlient()
 {
-    trenne();
+	trenne();
 #ifdef WIN32
-    OPENSSL_thread_stop();
+	OPENSSL_thread_stop();
 #endif
 }
 
 // nicht constant 
-void SSLSKlient::setEmpfangTimeout( int miliseconds ) // Setzt ein timeout fürs empfangen von daten
+void SSLSKlient::setEmpfangTimeout(int miliseconds) // Setzt ein timeout fürs empfangen von daten
 {
 #ifdef WIN32
-    DWORD timeout = miliseconds;
-    setsockopt( s, SOL_SOCKET, SO_RCVTIMEO, (const char*)&timeout, sizeof timeout );
+	DWORD timeout = miliseconds;
+	setsockopt(s, SOL_SOCKET, SO_RCVTIMEO, (const char*)&timeout, sizeof timeout);
 #else
-    struct timeval tv;
-    tv.tv_sec = miliseconds / 1000;
-    tv.tv_usec = (miliseconds % 1000) * 1000;
-    setsockopt( s, SOL_SOCKET, SO_RCVTIMEO, (const char*)&tv, sizeof tv );
+	struct timeval tv;
+	tv.tv_sec = miliseconds / 1000;
+	tv.tv_usec = (miliseconds % 1000) * 1000;
+	setsockopt(s, SOL_SOCKET, SO_RCVTIMEO, (const char*)&tv, sizeof tv);
 #endif
 }
 
-bool SSLSKlient::sende( const char* nachricht, int len ) // sendet zum Klient
+bool SSLSKlient::sende(const char* nachricht, int len) // sendet zum Klient
 {
-    if( !ssl )
-        return 0;
-    int ll = 0;
-    while( len > 0 )
-    {
-        int l = SSL_write( ssl, nachricht + ll, len );
-        if( l <= 0 )
-            return 0; // Fehler
-        len -= l;
-        ll += l;
-    }
-    upStreamBytes += ll;
-    return 1;
+	if (!ssl)
+		return 0;
+	int ll = 0;
+	while (len > 0)
+	{
+		int l = SSL_write(ssl, nachricht + ll, len);
+		if (l <= 0)
+			return 0; // Fehler
+		len -= l;
+		ll += l;
+	}
+	upStreamBytes += ll;
+	return 1;
 }
 
-bool SSLSKlient::getNachricht( char* nachricht, int len ) // empfängt Nachricht von Klient
+bool SSLSKlient::getNachricht(char* nachricht, int len) // empfängt Nachricht von Klient
 {
-    if( !ssl )
-        return 0;
-    int ll = 0;
-    while( len > 0 )
-    {
-        int l = (int)SSL_read( ssl, nachricht + ll, len );
-        if( l <= 0 )
-            return 0; // Fehler
-        len -= l;
-        ll += l;
-    }
-    downStreamBytes += ll;
-    return 1;
+	if (!ssl)
+		return 0;
+	int ll = 0;
+	while (len > 0)
+	{
+		int l = (int)SSL_read(ssl, nachricht + ll, len);
+		if (l <= 0)
+			return 0; // Fehler
+		len -= l;
+		ll += l;
+	}
+	downStreamBytes += ll;
+	return 1;
 }
 
-int SSLSKlient::getDownloadBytes( bool reset ) // gibt die anzahl von empfangen bytes zurück
+int SSLSKlient::getDownloadBytes(bool reset) // gibt die anzahl von empfangen bytes zurück
 {
-    int ret = downStreamBytes;
-    if( reset )
-        downStreamBytes = 0;
-    return ret;
+	int ret = downStreamBytes;
+	if (reset)
+		downStreamBytes = 0;
+	return ret;
 }
 
-int SSLSKlient::getUploadBytes( bool reset ) // gibt die anzahl von versendeter bytes zurück
+int SSLSKlient::getUploadBytes(bool reset) // gibt die anzahl von versendeter bytes zurück
 {
-    int ret = upStreamBytes;
-    if( reset )
-        upStreamBytes = 0;
-    return ret;
+	int ret = upStreamBytes;
+	if (reset)
+		upStreamBytes = 0;
+	return ret;
 }
 
 bool SSLSKlient::trenne() // trennt die Verbindung zum Klient
 {
-    if( !ssl )
-        return 0;
-    SSL_free( ssl );
-    if( closesocket( s ) < 0 ) // trennen
-        return 0;
-    ssl = 0;
-    s = 0;
-    return 1;
+	if (!ssl)
+		return 0;
+	SSL_free(ssl);
+	if (closesocket(s) < 0) // trennen
+		return 0;
+	ssl = 0;
+	s = 0;
+	return 1;
 }
 
 // constant 
-bool SSLSKlient::hatNachricht( int zeit ) const // Wartet eine Zeit Lang auf eine Nachricht
+bool SSLSKlient::hatNachricht(int zeit) const // Wartet eine Zeit Lang auf eine Nachricht
 {
-    fd_set set;
-    FD_ZERO( &set );
-    FD_SET( SSL_get_rfd( ssl ), &set );
-    timeval time = { zeit / 1000, zeit };
-    return SSL_pending( ssl ) > 0 || select( 0, &set, 0, 0, &time ) == 1;
+	fd_set set;
+	FD_ZERO(&set);
+	FD_SET(SSL_get_rfd(ssl), &set);
+	timeval time = { zeit / 1000, zeit };
+	return SSL_pending(ssl) > 0 || select(0, &set, 0, 0, &time) == 1;
 }
 
 unsigned short SSLSKlient::getPort() const // gibt den Port zurück
 {
-    return htons( clientAddr.sin_port );
+	return htons(clientAddr.sin_port);
 }
 
 const char* SSLSKlient::getIp() const // gibt die Ip des Klients zurück
 {
-    return inet_ntoa( clientAddr.sin_addr );
+	return inet_ntoa(clientAddr.sin_addr);
 }

Network/Server.h

@@ -11,141 +11,141 @@ struct SSL;
 
 namespace Framework
 {
-    namespace Encryption
-    {
-        class Key;
-    }
-    class Text;
+	namespace Encryption
+	{
+		class Key;
+	}
+	class Text;
 }
 
 using namespace Framework;
 
 namespace Network
 {
-    class Server; // aus dieser Datei
-    class SKlient; // aus dieser Datei
+	class Server; // aus dieser Datei
+	class SKlient; // aus dieser Datei
 
-    class Server : public virtual ReferenceCounter
-    {
-    private:
-        SOCKET sock;
-        SOCKADDR_IN addresse;
-        int klients;
+	class Server : public virtual ReferenceCounter
+	{
+	private:
+		SOCKET sock;
+		SOCKADDR_IN addresse;
+		int klients;
 
-    public:
-        // Konstruktor 
-        __declspec(dllexport) Server();
-        // Destruktor 
-        __declspec(dllexport) ~Server();
-        // nicht constant 
-        __declspec(dllexport) bool verbinde( unsigned short port, int warteschlangenLen ); // Öffnet das Socket
-        __declspec(dllexport) SKlient* getKlient(); // nimmt Klient an
-        __declspec(dllexport) int getKlients( bool reset ); // gibt die Anzahl der Klients zurück
-        __declspec(dllexport) bool trenne(); // beendet den Server
-        // constant
-        __declspec(dllexport) unsigned short getPort() const; // gibt den Port zurück
-        __declspec(dllexport) bool isConnected() const; // giebt 1 zurück, falls der Server verbunden ist
-    };
+	public:
+		// Konstruktor 
+		__declspec(dllexport) Server();
+		// Destruktor 
+		__declspec(dllexport) ~Server();
+		// nicht constant 
+		__declspec(dllexport) bool verbinde(unsigned short port, int warteschlangenLen); // Öffnet das Socket
+		__declspec(dllexport) SKlient* getKlient(); // nimmt Klient an
+		__declspec(dllexport) int getKlients(bool reset); // gibt die Anzahl der Klients zurück
+		__declspec(dllexport) bool trenne(); // beendet den Server
+		// constant
+		__declspec(dllexport) unsigned short getPort() const; // gibt den Port zurück
+		__declspec(dllexport) bool isConnected() const; // giebt 1 zurück, falls der Server verbunden ist
+	};
 
-    class SKlient : public EncryptedVerbindung, public virtual ReferenceCounter
-    {
-    private:
-        SOCKET sock;
-        sockaddr_in clientAddr;
-        Encryption::Key* sendeKey;
-        Encryption::Key* empfangKey;
-        int downStreamBytes;
-        int upStreamBytes;
+	class SKlient : public EncryptedVerbindung, public virtual ReferenceCounter
+	{
+	private:
+		SOCKET sock;
+		sockaddr_in clientAddr;
+		Encryption::Key* sendeKey;
+		Encryption::Key* empfangKey;
+		int downStreamBytes;
+		int upStreamBytes;
 
-    public:
-        // Konstruktor 
-        __declspec(dllexport) SKlient( sockaddr_in client, SOCKET sock );
-        // Destruktor 
-        __declspec(dllexport) ~SKlient();
-        // nicht constant 
-        __declspec(dllexport) void setEmpfangTimeout( int miliseconds ); // Setzt ein timeout fürs empfangen von daten
-        __declspec(dllexport) void setSendeKeyZ( Encryption::Key* key ); // Setzt den Schlüssel fürs Senden
-        __declspec(dllexport) void setEmpfangKeyZ( Encryption::Key* key ); // Setzt den Schlüssel fürs Empfangen
-        __declspec(dllexport) void setSendeKey( char* key, int len ); // Setzt den Schlüssel fürs Senden
-        __declspec(dllexport) void setEmpfangKey( char* key, int len ); // Setzt den Schlüssel fürs Empfangen
-        __declspec(dllexport) bool sende( const char* nachricht, int len ) override; // sendet zum Klient
-        __declspec(dllexport) bool getNachricht( char* nachricht, int len ) override; // empfängt Nachricht von Klient
-        __declspec(dllexport) bool sendeEncrypted( const char* nachricht, int len ) override; // sendet zum Server
-        __declspec(dllexport) bool getNachrichtEncrypted( char* nachricht, int len ) override; // empfängt Nachricht
-        __declspec(dllexport) int getDownloadBytes( bool reset ); // gibt die anzahl von empfangen bytes zurück
-        __declspec(dllexport) int getUploadBytes( bool reset ); // gibt die anzahl von versendeter bytes zurück
-        __declspec(dllexport) bool trenne(); // trennt die Verbindung zum Klient
-        // constant 
-        __declspec(dllexport) bool hatNachricht( int zeit ) const; // Wartet eine Zeit Lang auf eine Nachricht
-        __declspec(dllexport) unsigned short getPort() const; // gibt den Port zurück
-        __declspec(dllexport) const char* getIp() const; // gibt die Ip des Klients zurück
-        __declspec(dllexport) bool waitForNextMessage() const; // wartet bis es etwas zu empfangen gibt
-    };
+	public:
+		// Konstruktor 
+		__declspec(dllexport) SKlient(sockaddr_in client, SOCKET sock);
+		// Destruktor 
+		__declspec(dllexport) ~SKlient();
+		// nicht constant 
+		__declspec(dllexport) void setEmpfangTimeout(int miliseconds); // Setzt ein timeout fürs empfangen von daten
+		__declspec(dllexport) void setSendeKeyZ(Encryption::Key* key); // Setzt den Schlüssel fürs Senden
+		__declspec(dllexport) void setEmpfangKeyZ(Encryption::Key* key); // Setzt den Schlüssel fürs Empfangen
+		__declspec(dllexport) void setSendeKey(const char* key, int len); // Setzt den Schlüssel fürs Senden
+		__declspec(dllexport) void setEmpfangKey(const char* key, int len); // Setzt den Schlüssel fürs Empfangen
+		__declspec(dllexport) bool sende(const char* nachricht, int len) override; // sendet zum Klient
+		__declspec(dllexport) bool getNachricht(char* nachricht, int len) override; // empfängt Nachricht von Klient
+		__declspec(dllexport) bool sendeEncrypted(const char* nachricht, int len) override; // sendet zum Server
+		__declspec(dllexport) bool getNachrichtEncrypted(char* nachricht, int len) override; // empfängt Nachricht
+		__declspec(dllexport) int getDownloadBytes(bool reset); // gibt die anzahl von empfangen bytes zurück
+		__declspec(dllexport) int getUploadBytes(bool reset); // gibt die anzahl von versendeter bytes zurück
+		__declspec(dllexport) bool trenne(); // trennt die Verbindung zum Klient
+		// constant 
+		__declspec(dllexport) bool hatNachricht(int zeit) const; // Wartet eine Zeit Lang auf eine Nachricht
+		__declspec(dllexport) unsigned short getPort() const; // gibt den Port zurück
+		__declspec(dllexport) const char* getIp() const; // gibt die Ip des Klients zurück
+		__declspec(dllexport) bool waitForNextMessage() const; // wartet bis es etwas zu empfangen gibt
+	};
 
-    class SSLSKlient;
+	class SSLSKlient;
 
-    class SSLServer : public virtual ReferenceCounter
-    {
-    private:
-        SOCKET s;
-        SOCKADDR_IN addr;
-        SSL_CTX* ctx;
-        Text* passw;
-        int klients;
+	class SSLServer : public virtual ReferenceCounter
+	{
+	private:
+		SOCKET s;
+		SOCKADDR_IN addr;
+		SSL_CTX* ctx;
+		Text* passw;
+		int klients;
 
-    public:
-        // Konstruktor 
-        __declspec(dllexport) SSLServer();
-        // Destruktor 
-        __declspec(dllexport) ~SSLServer();
-        // nicht constant 
-        // Setzt den Pfad zur Datei, in dem das Certifikat gespeichert ist
-        __declspec(dllexport) bool setCertificateFile( const char* file );
-        // Setzt den Pfad zur Datei, in dem der private Schlüssel gespeichert ist
-        __declspec(dllexport) bool setPrivateKeyFile( const char* file );
-        // setzt das passwort des private keys (muss vor setPrivateKeyFile aufgerufen werden)
-        __declspec(dllexport) void setPrivateKeyPassword( const char* password );
-        // Öffnet das Socket
-        __declspec(dllexport) bool verbinde( unsigned short port, int warteschlangenLen );
-        // nimmt Klient an
-        __declspec(dllexport) SSLSKlient* getKlient();
-        // gibt die Anzahl der Klients zurück
-        __declspec(dllexport) int getKlients( bool reset );
-        // beendet den Server
-        __declspec(dllexport) bool trenne();
-        // constant
-        // gibt den Port zurück
-        __declspec(dllexport) unsigned short getPort() const;
-        // giebt 1 zurück, falls der Server verbunden ist
-        __declspec(dllexport) bool isConnected() const;
-    };
+	public:
+		// Konstruktor 
+		__declspec(dllexport) SSLServer();
+		// Destruktor 
+		__declspec(dllexport) ~SSLServer();
+		// nicht constant 
+		// Setzt den Pfad zur Datei, in dem das Certifikat gespeichert ist
+		__declspec(dllexport) bool setCertificateFile(const char* file);
+		// Setzt den Pfad zur Datei, in dem der private Schlüssel gespeichert ist
+		__declspec(dllexport) bool setPrivateKeyFile(const char* file);
+		// setzt das passwort des private keys (muss vor setPrivateKeyFile aufgerufen werden)
+		__declspec(dllexport) void setPrivateKeyPassword(const char* password);
+		// Öffnet das Socket
+		__declspec(dllexport) bool verbinde(unsigned short port, int warteschlangenLen);
+		// nimmt Klient an
+		__declspec(dllexport) SSLSKlient* getKlient();
+		// gibt die Anzahl der Klients zurück
+		__declspec(dllexport) int getKlients(bool reset);
+		// beendet den Server
+		__declspec(dllexport) bool trenne();
+		// constant
+		// gibt den Port zurück
+		__declspec(dllexport) unsigned short getPort() const;
+		// giebt 1 zurück, falls der Server verbunden ist
+		__declspec(dllexport) bool isConnected() const;
+	};
 
-    class SSLSKlient : public Verbindung, public virtual ReferenceCounter
-    {
-    private:
-        SOCKET s;
-        SSL* ssl;
-        sockaddr_in clientAddr;
-        int downStreamBytes;
-        int upStreamBytes;
+	class SSLSKlient : public Verbindung, public virtual ReferenceCounter
+	{
+	private:
+		SOCKET s;
+		SSL* ssl;
+		sockaddr_in clientAddr;
+		int downStreamBytes;
+		int upStreamBytes;
 
-    public:
-        // Konstruktor 
-        __declspec(dllexport) SSLSKlient( sockaddr_in client, SSL* ssl, SOCKET s );
-        // Destruktor 
-        __declspec(dllexport) ~SSLSKlient();
-        // nicht constant 
-        __declspec(dllexport) void setEmpfangTimeout( int miliseconds ); // Setzt ein timeout fürs empfangen von daten
-        __declspec(dllexport) bool sende( const char* nachricht, int len ) override; // sendet zum Klient
-        __declspec(dllexport) bool getNachricht( char* nachricht, int len ) override; // empfängt Nachricht von Klient
-        __declspec(dllexport) int getDownloadBytes( bool reset ); // gibt die anzahl von empfangen bytes zurück
-        __declspec(dllexport) int getUploadBytes( bool reset ); // gibt die anzahl von versendeter bytes zurück
-        __declspec(dllexport) bool trenne(); // trennt die Verbindung zum Klient
-        // constant 
-        __declspec(dllexport) bool hatNachricht( int zeit ) const; // Wartet eine Zeit Lang auf eine Nachricht
-        __declspec(dllexport) unsigned short getPort() const; // gibt den Port zurück
-        __declspec(dllexport) const char* getIp() const; // gibt die Ip des Klients zurück
-    };
+	public:
+		// Konstruktor 
+		__declspec(dllexport) SSLSKlient(sockaddr_in client, SSL* ssl, SOCKET s);
+		// Destruktor 
+		__declspec(dllexport) ~SSLSKlient();
+		// nicht constant 
+		__declspec(dllexport) void setEmpfangTimeout(int miliseconds); // Setzt ein timeout fürs empfangen von daten
+		__declspec(dllexport) bool sende(const char* nachricht, int len) override; // sendet zum Klient
+		__declspec(dllexport) bool getNachricht(char* nachricht, int len) override; // empfängt Nachricht von Klient
+		__declspec(dllexport) int getDownloadBytes(bool reset); // gibt die anzahl von empfangen bytes zurück
+		__declspec(dllexport) int getUploadBytes(bool reset); // gibt die anzahl von versendeter bytes zurück
+		__declspec(dllexport) bool trenne(); // trennt die Verbindung zum Klient
+		// constant 
+		__declspec(dllexport) bool hatNachricht(int zeit) const; // Wartet eine Zeit Lang auf eine Nachricht
+		__declspec(dllexport) unsigned short getPort() const; // gibt den Port zurück
+		__declspec(dllexport) const char* getIp() const; // gibt die Ip des Klients zurück
+	};
 }
 
 #endif

Network/WebSocket.cpp

@@ -6,408 +6,408 @@ using namespace Network;
 using namespace WebSocket;
 using namespace Framework;
 
-__declspec( dllexport ) Frame &Frame::operator+=( const Frame &b ) // baut frames zusammen welche zu einer nachricht gehören
+__declspec(dllexport) Frame& Frame::operator+=(const Frame& b) // baut frames zusammen welche zu einer nachricht gehören
 {
-    fin = b.fin;
-    if( opcode == 0 )
-        opcode = b.opcode;
-    dataLength += b.dataLength;
-    if( dataLength )
-    {
-        char *data = new char[ (int)dataLength ];
-        if( data )
-            memcpy( data, this->data, (int)( dataLength - b.dataLength ) );
-        if( b.data )
-            memcpy( data + dataLength, b.data, (int)b.dataLength );
-        delete[] this->data;
-        this->data = data;
-    }
-    else
-    {
-        delete[] this->data;
-        this->data = 0;
-    }
-    return *this;
+	fin = b.fin;
+	if (opcode == 0)
+		opcode = b.opcode;
+	dataLength += b.dataLength;
+	if (dataLength)
+	{
+		char* data = new char[(int)dataLength];
+		if (data)
+			memcpy(data, this->data, (int)(dataLength - b.dataLength));
+		if (b.data)
+			memcpy(data + dataLength, b.data, (int)b.dataLength);
+		delete[] this->data;
+		this->data = data;
+	}
+	else
+	{
+		delete[] this->data;
+		this->data = 0;
+	}
+	return *this;
 }
 
 
-__declspec( dllexport ) WebSocketClient::WebSocketClient( const char *path, const char *host, unsigned short port )
-    : Thread()
+__declspec(dllexport) WebSocketClient::WebSocketClient(const char* path, const char* host, unsigned short port)
+	: Thread()
 {
-    queue = new Array< Frame >();
-    callback = 0;
-    klient = 0;
-    this->path = path;
-    this->host = host;
-    this->port = port;
-    lastPingFrame = 0;
-    nextClose = 0;
+	queue = new Array< Frame >();
+	callback = 0;
+	klient = 0;
+	this->path = path;
+	this->host = host;
+	this->port = port;
+	lastPingFrame = 0;
+	nextClose = 0;
 }
 
 WebSocketClient::~WebSocketClient()
 {
-    disconnect();
-    while( queue->getEintragAnzahl() )
-    {
-        Frame f = queue->get( 0 );
-        delete[] f.data;
-        queue->remove( 0 );
-    }
-    queue->release();
+	disconnect();
+	while (queue->getEintragAnzahl())
+	{
+		Frame f = queue->get(0);
+		delete[] f.data;
+		queue->remove(0);
+	}
+	queue->release();
 }
 
-__declspec( dllexport ) void WebSocketClient::setMessageCallback( std::function< void( WebSocketClient *, __int64 size, const char *data, DataType typ ) > callback )
+__declspec(dllexport) void WebSocketClient::setMessageCallback(std::function< void(WebSocketClient*, __int64 size, const char* data, DataType typ) > callback)
 {
-    this->callback = callback;
+	this->callback = callback;
 }
 
-__declspec( dllexport ) bool WebSocketClient::connect()
+__declspec(dllexport) bool WebSocketClient::connect()
 {
-    char allowedKeyChars[] = { 'a', 'b','c','d','e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm',
-        'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z', '0', '1', '2', '3',
-        '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K',
-        'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z', 0 };
-    __int64 numKeyChars = strlen( allowedKeyChars );
-    if( !klient )
-    {
-        Text message = "GET ";
-        message += path;
-        message += " HTTP/1.1\r\n";
-        message += "Host: ";
-        message += host;
-        message += "\r\nUpgrade: websocket\r\n";
-        message += "Connection: Upgrade\r\n";
-        char *key = new char[ 25 ];
-        key[ 24 ] = 0;
-        key[ 23 ] = '=';
-        key[ 22 ] = '=';
-        for( int i = 0; i < 22; i++ )
-            key[ i ] = allowedKeyChars[ (int)( gen.rand() * numKeyChars ) ];
-        message += "Sec-WebSocket-Key: ";
-        message += key;
-        delete[] key;
-        message += "\r\nSec-WebSocket-Version: 13\r\n\r\n";
-        klient = new Klient();
-        if( !klient->verbinde( port, host ) )
-        {
-            klient = (Klient *)klient->release();
-            return 0;
-        }
-        klient->sende( message, message.getLength() );
-        Text answer;
-        int br = 0;
-        do
-        {
-            char buff[ 2 ];
-            buff[ 1 ] = 0;
-            if( klient->getNachricht( buff, 1 ) )
-                answer += buff;
-            else
-                break;
-            if( buff[ 0 ] == '\n' )
-                br++;
-            else if( buff[ 0 ] != '\r' )
-                br = 0;
-        } while( br < 2 && klient->hatNachricht( 1000 ) );
-        HTTP::Answer *handshakeResponse = new HTTP::Answer( answer );
-        if( handshakeResponse->getStatusCode() != 101 )
-        {
-            handshakeResponse->release();
-            klient = (Klient *)klient->release();
-            return 0;
-        }
-        handshakeResponse->release();
-        start();
-        return 1;
-    }
-    else
-        return 1;
+	char allowedKeyChars[] = { 'a', 'b','c','d','e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm',
+		'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z', '0', '1', '2', '3',
+		'4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K',
+		'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z', 0 };
+	__int64 numKeyChars = strlen(allowedKeyChars);
+	if (!klient)
+	{
+		Text message = "GET ";
+		message += path;
+		message += " HTTP/1.1\r\n";
+		message += "Host: ";
+		message += host;
+		message += "\r\nUpgrade: websocket\r\n";
+		message += "Connection: Upgrade\r\n";
+		char* key = new char[25];
+		key[24] = 0;
+		key[23] = '=';
+		key[22] = '=';
+		for (int i = 0; i < 22; i++)
+			key[i] = allowedKeyChars[(int)(gen.rand() * numKeyChars)];
+		message += "Sec-WebSocket-Key: ";
+		message += key;
+		delete[] key;
+		message += "\r\nSec-WebSocket-Version: 13\r\n\r\n";
+		klient = new Klient();
+		if (!klient->verbinde(port, host))
+		{
+			klient = (Klient*)klient->release();
+			return 0;
+		}
+		klient->sende(message, message.getLength());
+		Text answer;
+		int br = 0;
+		do
+		{
+			char buff[2];
+			buff[1] = 0;
+			if (klient->getNachricht(buff, 1))
+				answer += buff;
+			else
+				break;
+			if (buff[0] == '\n')
+				br++;
+			else if (buff[0] != '\r')
+				br = 0;
+		} while (br < 2 && klient->hatNachricht(1000));
+		HTTP::Answer* handshakeResponse = new HTTP::Answer(answer);
+		if (handshakeResponse->getStatusCode() != 101)
+		{
+			handshakeResponse->release();
+			klient = (Klient*)klient->release();
+			return 0;
+		}
+		handshakeResponse->release();
+		start();
+		return 1;
+	}
+	else
+		return 1;
 }
 
-__declspec( dllexport ) bool WebSocketClient::send( __int64 size, const char *data, DataType typ )
+__declspec(dllexport) bool WebSocketClient::send(__int64 size, const char* data, DataType typ)
 {
-    Frame f;
-    f.fin = 1;
-    f.rsv1 = 0;
-    f.rsv2 = 0;
-    f.rsv3 = 0;
-    f.mask = 1;
-    if( typ == TEXT )
-        f.opcode = 1;
-    else
-        f.opcode = 2;
-    f.dataLength = size;
-    f.data = new char[ (int)f.dataLength ];
-    memcpy( f.data, data, (int)f.dataLength );
-    f.key[ 0 ] = (unsigned char)( gen.rand() * 256 );
-    f.key[ 1 ] = (unsigned char)( gen.rand() * 256 );
-    f.key[ 2 ] = (unsigned char)( gen.rand() * 256 );
-    f.key[ 3 ] = (unsigned char)( gen.rand() * 256 );
-    c.lock();
-    queue->add( f );
-    c.unlock();
-    return 1;
+	Frame f;
+	f.fin = 1;
+	f.rsv1 = 0;
+	f.rsv2 = 0;
+	f.rsv3 = 0;
+	f.mask = 1;
+	if (typ == TEXT)
+		f.opcode = 1;
+	else
+		f.opcode = 2;
+	f.dataLength = size;
+	f.data = new char[(int)f.dataLength];
+	memcpy(f.data, data, (int)f.dataLength);
+	f.key[0] = (unsigned char)(gen.rand() * 256);
+	f.key[1] = (unsigned char)(gen.rand() * 256);
+	f.key[2] = (unsigned char)(gen.rand() * 256);
+	f.key[3] = (unsigned char)(gen.rand() * 256);
+	c.lock();
+	queue->add(f);
+	c.unlock();
+	return 1;
 }
 
-__declspec( dllexport ) void WebSocketClient::thread()
+__declspec(dllexport) void WebSocketClient::thread()
 {
-    while( klient )
-    {
-        c2.lock();
-        if( !klient )
-        {
-            c2.unlock();
-            return;
-        }
-        if( klient->hatNachricht( 100 ) )
-        {
-            bool ok = 1;
-            c2.unlock();
-            bool first = 1;
-            Frame m;
-            unsigned char byte;
-            do
-            {
-                c2.lock();
-                if( !klient )
-                {
-                    c2.unlock();
-                    return;
-                }
-                Frame message;
-                ok &= klient->getNachricht( (char *)&byte, 1 );
-                message.fin = ( byte & 0x80 ) != 0;
-                message.rsv1 = ( byte & 0x40 ) != 0;
-                message.rsv2 = ( byte & 0x20 ) != 0;
-                message.rsv3 = ( byte & 0x10 ) != 0;
-                message.opcode = byte & 0xF;
-                ok &= klient->getNachricht( (char *)&byte, 1 );
-                message.mask = ( byte & 0x80 ) != 0;
-                message.dataLength = byte & 0x7F;
-                if( message.dataLength == 126 )
-                {
-                    ok &= klient->getNachricht( (char *)&byte, 1 );
-                    message.dataLength = byte << 8;
-                    ok &= klient->getNachricht( (char *)&byte, 1 );
-                    message.dataLength |= byte;
-                }
-                else if( message.dataLength == 127 )
-                {
-                    ok &= klient->getNachricht( (char *)&byte, 1 );
-                    message.dataLength = (__int64)byte << 56;
-                    ok &= klient->getNachricht( (char *)&byte, 1 );
-                    message.dataLength |= (__int64)byte << 48;
-                    ok &= klient->getNachricht( (char *)&byte, 1 );
-                    message.dataLength |= (__int64)byte << 40;
-                    ok &= klient->getNachricht( (char *)&byte, 1 );
-                    message.dataLength |= (__int64)byte << 32;
-                    ok &= klient->getNachricht( (char *)&byte, 1 );
-                    message.dataLength |= (__int64)byte << 24;
-                    ok &= klient->getNachricht( (char *)&byte, 1 );
-                    message.dataLength |= (__int64)byte << 16;
-                    ok &= klient->getNachricht( (char *)&byte, 1 );
-                    message.dataLength |= (__int64)byte << 8;
-                    ok &= klient->getNachricht( (char *)&byte, 1 );
-                    message.dataLength |= (__int64)byte;
-                }
-                if( message.mask )
-                {
-                    ok &= klient->getNachricht( (char *)&byte, 1 );
-                    message.key[ 0 ] = byte;
-                    ok &= klient->getNachricht( (char *)&byte, 1 );
-                    message.key[ 1 ] = byte;
-                    ok &= klient->getNachricht( (char *)&byte, 1 );
-                    message.key[ 2 ] = byte;
-                    ok &= klient->getNachricht( (char *)&byte, 1 );
-                    message.key[ 3 ] = byte;
-                }
-                if( !ok )
-                    message.dataLength = 1;
-                message.data = 0;
-                if( message.dataLength )
-                    message.data = new char[ (int)message.dataLength ];
-                for( int i = 0; i < message.dataLength; i++ )
-                {
-                    ok &= klient->getNachricht( (char *)&byte, 1 );
-                    if( message.mask )
-                        message.data[ i ] = byte ^ message.key[ i % 4 ];
-                    else
-                        message.data[ i ] = byte;
-                }
-                c2.unlock();
-                if( first )
-                    m = message;
-                else
-                {
-                    m += message;
-                    delete[] message.data;
-                }
-                first = 0;
-                if( !ok )
-                    break;
-            } while( !m.fin );
-            if( !ok )
-            {
-                delete[] m.data;
-                return;
-            }
-            if( m.opcode == 0x9 )
-            {
-                m.opcode = 0xA;
-                m.key[ 0 ] = (unsigned char)( gen.rand() * 256 );
-                m.key[ 1 ] = (unsigned char)( gen.rand() * 256 );
-                m.key[ 2 ] = (unsigned char)( gen.rand() * 256 );
-                m.key[ 3 ] = (unsigned char)( gen.rand() * 256 );
-                queue->add( m );
-            }
-            else if( m.opcode == 0xA )
-            {
-                delete[] m.data;
-            }
-            else if( m.opcode == 0x8 )
-            {
-                if( nextClose )
-                {
-                    delete[] m.data;
-                    c2.lock();
-                    klient->trenne();
-                    klient = (Klient *)klient->release();
-                    c2.unlock();
-                    return;
-                }
-                else
-                {
-                    m.key[ 0 ] = (unsigned char)( gen.rand() * 256 );
-                    m.key[ 1 ] = (unsigned char)( gen.rand() * 256 );
-                    m.key[ 2 ] = (unsigned char)( gen.rand() * 256 );
-                    m.key[ 3 ] = (unsigned char)( gen.rand() * 256 );
-                    queue->add( m );
-                    nextClose = 1;
-                }
-            }
-            else if( callback )
-            {
-                callback( this, m.dataLength, m.data, m.opcode == 1 ? TEXT : BINARY );
-                delete[] m.data;
-            }
-        }
-        else
-        {
-            c2.unlock();
-            c.lock();
-            while( queue->getEintragAnzahl() )
-            {
-                Frame f = queue->get( 0 );
-                c.unlock();
-                unsigned char byte = ( f.fin ? 1 : 0 ) << 7;
-                byte |= ( f.rsv1 ? 1 : 0 ) << 6;
-                byte |= ( f.rsv2 ? 1 : 0 ) << 5;
-                byte |= ( f.rsv3 ? 1 : 0 ) << 4;
-                byte |= f.opcode & 0xF;
-                c2.lock();
-                if( !klient )
-                {
-                    c2.unlock();
-                    return;
-                }
-                klient->sende( (char *)&byte, 1 );
-                byte = ( f.mask ? 1 : 0 ) << 7;
-                if( f.dataLength < 126 )
-                    byte |= (unsigned char)f.dataLength & 0x7F;
-                else if( f.dataLength <= 32767 )
-                    byte |= 126;
-                else
-                    byte |= 127;
-                klient->sende( (char *)&byte, 1 );
-                if( f.dataLength >= 126 )
-                {
-                    if( f.dataLength <= 32767 )
-                    {
-                        byte = (unsigned char)( f.dataLength >> 8 );
-                        klient->sende( (char *)&byte, 1 );
-                        byte = (unsigned char)f.dataLength & 0xFF;
-                        klient->sende( (char *)&byte, 1 );
-                    }
-                    else
-                    {
-                        byte = (unsigned char)( f.dataLength >> 56 );
-                        klient->sende( (char *)&byte, 1 );
-                        byte = (unsigned char)( f.dataLength >> 48 );
-                        klient->sende( (char *)&byte, 1 );
-                        byte = (unsigned char)( f.dataLength >> 40 );
-                        klient->sende( (char *)&byte, 1 );
-                        byte = (unsigned char)( f.dataLength >> 32 );
-                        klient->sende( (char *)&byte, 1 );
-                        byte = (unsigned char)( f.dataLength >> 24 );
-                        klient->sende( (char *)&byte, 1 );
-                        byte = (unsigned char)( f.dataLength >> 16 );
-                        klient->sende( (char *)&byte, 1 );
-                        byte = (unsigned char)( f.dataLength >> 8 );
-                        klient->sende( (char *)&byte, 1 );
-                        byte = (unsigned char)f.dataLength & 0xFF;
-                        klient->sende( (char *)&byte, 1 );
-                    }
-                }
-                if( f.mask )
-                {
-                    byte = (unsigned char)f.key[ 0 ];
-                    klient->sende( (char *)&byte, 1 );
-                    byte = (unsigned char)f.key[ 1 ];
-                    klient->sende( (char *)&byte, 1 );
-                    byte = (unsigned char)f.key[ 2 ];
-                    klient->sende( (char *)&byte, 1 );
-                    byte = (unsigned char)f.key[ 3 ];
-                    klient->sende( (char *)&byte, 1 );
-                }
-                if( f.dataLength )
-                {
-                    for( int i = 0; i < f.dataLength; i++ )
-                    {
-                        if( f.mask )
-                            byte = (unsigned char)f.data[ i ] ^ f.key[ i % 4 ];
-                        else
-                            byte = (unsigned char)f.data[ i ];
-                        klient->sende( (char *)&byte, 1 );
-                    }
-                }
-                c2.unlock();
-                delete[] f.data;
-                c.lock();
-                queue->remove( 0 );
-                if( f.opcode == 0x8 )
-                {
-                    if( nextClose )
-                    {
-                        c.unlock();
-                        c2.lock();
-                        klient->trenne();
-                        klient = (Klient *)klient->release();
-                        c2.unlock();
-                        return;
-                    }
-                    else
-                    {
-                        nextClose = 1;
-                    }
-                }
-            }
-            c.unlock();
-        }
-    }
+	while (klient)
+	{
+		c2.lock();
+		if (!klient)
+		{
+			c2.unlock();
+			return;
+		}
+		if (klient->hatNachricht(100))
+		{
+			bool ok = 1;
+			c2.unlock();
+			bool first = 1;
+			Frame m;
+			unsigned char byte;
+			do
+			{
+				c2.lock();
+				if (!klient)
+				{
+					c2.unlock();
+					return;
+				}
+				Frame message;
+				ok &= klient->getNachricht((char*)&byte, 1);
+				message.fin = (byte & 0x80) != 0;
+				message.rsv1 = (byte & 0x40) != 0;
+				message.rsv2 = (byte & 0x20) != 0;
+				message.rsv3 = (byte & 0x10) != 0;
+				message.opcode = byte & 0xF;
+				ok &= klient->getNachricht((char*)&byte, 1);
+				message.mask = (byte & 0x80) != 0;
+				message.dataLength = byte & 0x7F;
+				if (message.dataLength == 126)
+				{
+					ok &= klient->getNachricht((char*)&byte, 1);
+					message.dataLength = byte << 8;
+					ok &= klient->getNachricht((char*)&byte, 1);
+					message.dataLength |= byte;
+				}
+				else if (message.dataLength == 127)
+				{
+					ok &= klient->getNachricht((char*)&byte, 1);
+					message.dataLength = (__int64)byte << 56;
+					ok &= klient->getNachricht((char*)&byte, 1);
+					message.dataLength |= (__int64)byte << 48;
+					ok &= klient->getNachricht((char*)&byte, 1);
+					message.dataLength |= (__int64)byte << 40;
+					ok &= klient->getNachricht((char*)&byte, 1);
+					message.dataLength |= (__int64)byte << 32;
+					ok &= klient->getNachricht((char*)&byte, 1);
+					message.dataLength |= (__int64)byte << 24;
+					ok &= klient->getNachricht((char*)&byte, 1);
+					message.dataLength |= (__int64)byte << 16;
+					ok &= klient->getNachricht((char*)&byte, 1);
+					message.dataLength |= (__int64)byte << 8;
+					ok &= klient->getNachricht((char*)&byte, 1);
+					message.dataLength |= (__int64)byte;
+				}
+				if (message.mask)
+				{
+					ok &= klient->getNachricht((char*)&byte, 1);
+					message.key[0] = byte;
+					ok &= klient->getNachricht((char*)&byte, 1);
+					message.key[1] = byte;
+					ok &= klient->getNachricht((char*)&byte, 1);
+					message.key[2] = byte;
+					ok &= klient->getNachricht((char*)&byte, 1);
+					message.key[3] = byte;
+				}
+				if (!ok)
+					message.dataLength = 1;
+				message.data = 0;
+				if (message.dataLength)
+					message.data = new char[(int)message.dataLength];
+				for (int i = 0; i < message.dataLength; i++)
+				{
+					ok &= klient->getNachricht((char*)&byte, 1);
+					if (message.mask)
+						message.data[i] = byte ^ message.key[i % 4];
+					else
+						message.data[i] = byte;
+				}
+				c2.unlock();
+				if (first)
+					m = message;
+				else
+				{
+					m += message;
+					delete[] message.data;
+				}
+				first = 0;
+				if (!ok)
+					break;
+			} while (!m.fin);
+			if (!ok)
+			{
+				delete[] m.data;
+				return;
+			}
+			if (m.opcode == 0x9)
+			{
+				m.opcode = 0xA;
+				m.key[0] = (unsigned char)(gen.rand() * 256);
+				m.key[1] = (unsigned char)(gen.rand() * 256);
+				m.key[2] = (unsigned char)(gen.rand() * 256);
+				m.key[3] = (unsigned char)(gen.rand() * 256);
+				queue->add(m);
+			}
+			else if (m.opcode == 0xA)
+			{
+				delete[] m.data;
+			}
+			else if (m.opcode == 0x8)
+			{
+				if (nextClose)
+				{
+					delete[] m.data;
+					c2.lock();
+					klient->trenne();
+					klient = (Klient*)klient->release();
+					c2.unlock();
+					return;
+				}
+				else
+				{
+					m.key[0] = (unsigned char)(gen.rand() * 256);
+					m.key[1] = (unsigned char)(gen.rand() * 256);
+					m.key[2] = (unsigned char)(gen.rand() * 256);
+					m.key[3] = (unsigned char)(gen.rand() * 256);
+					queue->add(m);
+					nextClose = 1;
+				}
+			}
+			else if (callback)
+			{
+				callback(this, m.dataLength, m.data, m.opcode == 1 ? TEXT : BINARY);
+				delete[] m.data;
+			}
+		}
+		else
+		{
+			c2.unlock();
+			c.lock();
+			while (queue->getEintragAnzahl())
+			{
+				Frame f = queue->get(0);
+				c.unlock();
+				unsigned char byte = (f.fin ? 1 : 0) << 7;
+				byte |= (f.rsv1 ? 1 : 0) << 6;
+				byte |= (f.rsv2 ? 1 : 0) << 5;
+				byte |= (f.rsv3 ? 1 : 0) << 4;
+				byte |= f.opcode & 0xF;
+				c2.lock();
+				if (!klient)
+				{
+					c2.unlock();
+					return;
+				}
+				klient->sende((char*)&byte, 1);
+				byte = (f.mask ? 1 : 0) << 7;
+				if (f.dataLength < 126)
+					byte |= (unsigned char)f.dataLength & 0x7F;
+				else if (f.dataLength <= 32767)
+					byte |= 126;
+				else
+					byte |= 127;
+				klient->sende((char*)&byte, 1);
+				if (f.dataLength >= 126)
+				{
+					if (f.dataLength <= 32767)
+					{
+						byte = (unsigned char)(f.dataLength >> 8);
+						klient->sende((char*)&byte, 1);
+						byte = (unsigned char)f.dataLength & 0xFF;
+						klient->sende((char*)&byte, 1);
+					}
+					else
+					{
+						byte = (unsigned char)(f.dataLength >> 56);
+						klient->sende((char*)&byte, 1);
+						byte = (unsigned char)(f.dataLength >> 48);
+						klient->sende((char*)&byte, 1);
+						byte = (unsigned char)(f.dataLength >> 40);
+						klient->sende((char*)&byte, 1);
+						byte = (unsigned char)(f.dataLength >> 32);
+						klient->sende((char*)&byte, 1);
+						byte = (unsigned char)(f.dataLength >> 24);
+						klient->sende((char*)&byte, 1);
+						byte = (unsigned char)(f.dataLength >> 16);
+						klient->sende((char*)&byte, 1);
+						byte = (unsigned char)(f.dataLength >> 8);
+						klient->sende((char*)&byte, 1);
+						byte = (unsigned char)f.dataLength & 0xFF;
+						klient->sende((char*)&byte, 1);
+					}
+				}
+				if (f.mask)
+				{
+					byte = (unsigned char)f.key[0];
+					klient->sende((char*)&byte, 1);
+					byte = (unsigned char)f.key[1];
+					klient->sende((char*)&byte, 1);
+					byte = (unsigned char)f.key[2];
+					klient->sende((char*)&byte, 1);
+					byte = (unsigned char)f.key[3];
+					klient->sende((char*)&byte, 1);
+				}
+				if (f.dataLength)
+				{
+					for (int i = 0; i < f.dataLength; i++)
+					{
+						if (f.mask)
+							byte = (unsigned char)f.data[i] ^ f.key[i % 4];
+						else
+							byte = (unsigned char)f.data[i];
+						klient->sende((char*)&byte, 1);
+					}
+				}
+				c2.unlock();
+				delete[] f.data;
+				c.lock();
+				queue->remove(0);
+				if (f.opcode == 0x8)
+				{
+					if (nextClose)
+					{
+						c.unlock();
+						c2.lock();
+						klient->trenne();
+						klient = (Klient*)klient->release();
+						c2.unlock();
+						return;
+					}
+					else
+					{
+						nextClose = 1;
+					}
+				}
+			}
+			c.unlock();
+		}
+	}
 }
 
-__declspec( dllexport ) void WebSocketClient::disconnect()
+__declspec(dllexport) void WebSocketClient::disconnect()
 {
-    if( !klient )
-        return;
-    c2.lock();
-    klient->trenne();
-    klient = (Klient *)klient->release();
-    c2.unlock();
-    warteAufThread( 1000 );
+	if (!klient)
+		return;
+	c2.lock();
+	klient->trenne();
+	klient = (Klient*)klient->release();
+	c2.unlock();
+	warteAufThread(1000);
 }
 
-__declspec( dllexport ) bool WebSocketClient::isConnected() const
+__declspec(dllexport) bool WebSocketClient::isConnected() const
 {
-    return klient != 0;
+	return klient != 0;
 }

Network/WebSocket.h

@@ -8,63 +8,63 @@
 
 namespace Network
 {
-    namespace WebSocket
-    {
-        struct Frame
-        {
-            bool fin, rsv1, rsv2, rsv3; // bit 0 bis 3
-            char opcode; // bit 4 bis 7
-            bool mask; // bit 8
-            __int64 dataLength; // bit 9 bis 15 oder bis 31 oder bis 79
-            unsigned char key[ 4 ]; // wenn mask = 1 dann die nächsten 32 bits 
-            char *data; // die daten
-             // baut frames zusammen welche zu einer nachricht gehören
-            __declspec( dllexport ) Frame &operator+=( const Frame &b );
-        };
+	namespace WebSocket
+	{
+		struct Frame
+		{
+			bool fin, rsv1, rsv2, rsv3; // bit 0 bis 3
+			char opcode; // bit 4 bis 7
+			bool mask; // bit 8
+			__int64 dataLength; // bit 9 bis 15 oder bis 31 oder bis 79
+			unsigned char key[4]; // wenn mask = 1 dann die nächsten 32 bits 
+			char* data; // die daten
+			// baut frames zusammen welche zu einer nachricht gehören
+			__declspec(dllexport) Frame& operator+=(const Frame& b);
+		};
 
-        enum DataType
-        {
-            TEXT,
-            BINARY
-        };
+		enum DataType
+		{
+			TEXT,
+			BINARY
+		};
 
-        class WebSocketClient : public Framework::Thread
-        {
-        private:
-            std::function< void( WebSocketClient *, __int64 size, const char *data, DataType typ ) > callback;
-            Klient *klient;
-            Framework::Text path;
-            Framework::Text host;
-            Frame *lastPingFrame;
-            Array< Frame > *queue;
-            unsigned short port;
-            Critical c;
-            Critical c2;
-            RandomGenerator gen;
-            bool nextClose;
+		class WebSocketClient : public Framework::Thread
+		{
+		private:
+			std::function< void(WebSocketClient*, __int64 size, const char* data, DataType typ) > callback;
+			Klient* klient;
+			Framework::Text path;
+			Framework::Text host;
+			Frame* lastPingFrame;
+			Array< Frame >* queue;
+			unsigned short port;
+			Critical c;
+			Critical c2;
+			RandomGenerator gen;
+			bool nextClose;
 
-        public:
-            // Erstellt ein neues Websocket
-            //  path: Der Pfad zur Resource
-            //  host: Die Adresse des Servers
-            //  port: Der Port des Servers
-            __declspec( dllexport ) WebSocketClient( const char *path, const char *host, unsigned short port );
-            __declspec( dllexport ) virtual ~WebSocketClient();
-            // Setzt die Funktion, welche zum verarbeiten von Servernachrichten aufgerufen werden soll
-            __declspec( dllexport ) void setMessageCallback( std::function< void( WebSocketClient *, __int64 size, const char *data, DataType typ ) > callback );
-            // Führt den WebSocket Handshake aus falls noch nicht verbunden
-            __declspec( dllexport ) bool connect();
-            // Sendet eine Nachricht an den Server
-            //  size: Die länge der Nachricht
-            //  data: Die Daten
-            //  typ: Den Typ der Nachricht
-            __declspec( dllexport ) bool send( __int64 size, const char *data, DataType typ = TEXT );
-            // Diese Funktion verarbeitet Servernachrichten. Sie sollte nicht manuell aufgerufen werden, da sie automatisch gestartet wird
-            __declspec( dllexport ) void thread() override;
-            // bricht die verbindung ab
-            __declspec( dllexport ) void disconnect();
-            // Gibt 1 zurück, wenn eine Verbindung zum Server besteht, 0 sonnst
-            __declspec( dllexport ) bool isConnected() const;
-        };
-    }
+		public:
+			// Erstellt ein neues Websocket
+			//  path: Der Pfad zur Resource
+			//  host: Die Adresse des Servers
+			//  port: Der Port des Servers
+			__declspec(dllexport) WebSocketClient(const char* path, const char* host, unsigned short port);
+			__declspec(dllexport) virtual ~WebSocketClient();
+			// Setzt die Funktion, welche zum verarbeiten von Servernachrichten aufgerufen werden soll
+			__declspec(dllexport) void setMessageCallback(std::function< void(WebSocketClient*, __int64 size, const char* data, DataType typ) > callback);
+			// Führt den WebSocket Handshake aus falls noch nicht verbunden
+			__declspec(dllexport) bool connect();
+			// Sendet eine Nachricht an den Server
+			//  size: Die länge der Nachricht
+			//  data: Die Daten
+			//  typ: Den Typ der Nachricht
+			__declspec(dllexport) bool send(__int64 size, const char* data, DataType typ = TEXT);
+			// Diese Funktion verarbeitet Servernachrichten. Sie sollte nicht manuell aufgerufen werden, da sie automatisch gestartet wird
+			__declspec(dllexport) void thread() override;
+			// bricht die verbindung ab
+			__declspec(dllexport) void disconnect();
+			// Gibt 1 zurück, wenn eine Verbindung zum Server besteht, 0 sonnst
+			__declspec(dllexport) bool isConnected() const;
+		};
+	}
 }