translate code to english

Network Linux.vcxproj

@@ -60,13 +60,13 @@
   </PropertyGroup>
   <ItemGroup>
     <ClCompile Include="Network\HttpRequest.cpp" />
-    <ClCompile Include="Network\Klient.cpp" />
+    <ClCompile Include="Network\Client.cpp" />
     <ClCompile Include="Network\Network.cpp" />
     <ClCompile Include="Network\Server.cpp" />
   </ItemGroup>
   <ItemGroup>
     <ClInclude Include="Network\HttpRequest.h" />
-    <ClInclude Include="Network\Klient.h" />
+    <ClCompile Include="Network\Client.h" />
     <ClInclude Include="Network\Network.h" />
     <ClInclude Include="Network\Server.h" />
   </ItemGroup>

Network Linux.vcxproj.filters

@@ -15,7 +15,7 @@
     <ClCompile Include="Network\Network.cpp">
       <Filter>Quelldateien</Filter>
     </ClCompile>
-    <ClCompile Include="Network\Klient.cpp">
+    <ClCompile Include="Network\Client.cpp">
       <Filter>Quelldateien</Filter>
     </ClCompile>
     <ClCompile Include="Network\HttpRequest.cpp">
@@ -29,7 +29,7 @@
     <ClInclude Include="Network\Network.h">
       <Filter>Headerdateien</Filter>
     </ClInclude>
-    <ClInclude Include="Network\Klient.h">
+    <ClInclude Include="Network\Client.h">
       <Filter>Headerdateien</Filter>
     </ClInclude>
     <ClInclude Include="Network\HttpRequest.h">

Network/Klient.cpp → Network/Client.cpp

@@ -1,5 +1,5 @@
-#define INCLUDE_SSL
-#include "Klient.h"
+#define INCLUDE_SSL
+#include "Client.h"
 
 #ifndef WIN32
 #    include <netdb.h>
@@ -12,9 +12,9 @@
 
 using namespace Network;
 
-// inhalt der Klient Klasse aus Klient.h
-// Konstruktor
-Klient::Klient()
+// Content of the Client class from Client.h
+// Constructor
+Client::Client()
     : ReferenceCounter(),
       errorOccured(0)
 {
@@ -23,53 +23,53 @@ Klient::Klient()
     downStreamBytes = 0;
     upStreamBytes = 0;
     sock = 0;
-    sendeKey = 0;
-    empfangKey = 0;
+    sendKey = 0;
+    receiveKey = 0;
 }
 
-// Destruktoe
-Klient::~Klient()
+// Destructor
+Client::~Client()
 {
-    if (sock) trenne();
-    if (sendeKey) sendeKey->release();
-    if (empfangKey) empfangKey->release();
+    if (sock) disconnect();
+    if (sendKey) sendKey->release();
+    if (receiveKey) receiveKey->release();
 }
 
-// nicht constant
-void Klient::setSendeKeyZ(Encryption::Key* key) // Setzt den Key fürs Senden
+// non-constant
+void Client::setSendKeyZ(Encryption::Key* key) // Sets the key for sending
 {
-    if (sendeKey) sendeKey->release();
-    sendeKey = key;
+    if (sendKey) sendKey->release();
+    sendKey = key;
 }
 
-void Klient::setEmpfangKeyZ(
-    Encryption::Key* key) // Setzt den Key fürs Empfangen
+void Client::setReceiveKeyZ(
+    Encryption::Key* key) // Sets the key for receiving
 {
-    if (empfangKey) empfangKey->release();
-    empfangKey = key;
+    if (receiveKey) receiveKey->release();
+    receiveKey = key;
 }
 
-void Klient::setSendeKey(const char* key, int len) // Setzt den Key fürs Senden
+void Client::setSendKey(const char* key, int len) // Sets the key for sending
 {
-    if (!sendeKey) sendeKey = new Encryption::Key();
-    sendeKey->setKey(key, len);
+    if (!sendKey) sendKey = new Encryption::Key();
+    sendKey->setKey(key, len);
 }
 
-void Klient::setEmpfangKey(
-    const char* key, int len) // Setzt den Key fürs Empfangen
+void Client::setReceiveKey(
+    const char* key, int len) // Sets the key for receiving
 {
-    if (!empfangKey) empfangKey = new Encryption::Key();
-    empfangKey->setKey(key, len);
+    if (!receiveKey) receiveKey = new Encryption::Key();
+    receiveKey->setKey(key, len);
 }
 
-bool Klient::verbinde(
-    unsigned short port, const char* ip) // verbindet mit Server
+bool Client::connect(
+    unsigned short port, const char* ip) // connects to server
 {
-    if (sendeKey) sendeKey->setPos(0);
-    if (empfangKey) empfangKey->setPos(0);
+    if (sendKey) sendKey->setPos(0);
+    if (receiveKey) receiveKey->setPos(0);
     if (sock) closesocket(sock);
     sock = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
-    long sIp = inet_addr(ip); // ip addresse
+    long sIp = inet_addr(ip); // ip address
     if (sIp == INADDR_NONE)
     {
         struct hostent* pHostInfo = gethostbyname(ip);
@@ -79,24 +79,24 @@ bool Klient::verbinde(
     memcpy((char*)&server.sin_addr, &sIp, sizeof(sIp));
     server.sin_port = htons(port); // port
     if (connect(sock, (struct sockaddr*)&server, sizeof(server))
-        < 0) // verbinden
+        < 0) // connect
     {
         errorOccured = 1;
-        return 0; // Fehler
+        return 0; // Error
     }
     errorOccured = 0;
     return 1;
 }
 
-bool Klient::sende(const char* nachricht, int len) // sendet zum Server
+bool Client::send(const char* message, int len) // sends to server
 {
     int ll = 0;
     while (len > 0)
     {
 #ifdef WIN32
-        int l = send(sock, nachricht + ll, len, 0);
+        int l = send(sock, message + ll, len, 0);
 #else
-        int l = (int)send(sock, nachricht + ll, len, MSG_NOSIGNAL);
+        int l = (int)send(sock, message + ll, len, MSG_NOSIGNAL);
 #endif
         if (l <= 0)
         {
@@ -107,7 +107,7 @@ bool Klient::sende(const char* nachricht, int len) // sendet zum Server
 #    endif
 #endif
             errorOccured = 1;
-            return 0; // Fehler
+            return 0; // Error
         }
         len -= l;
         ll += l;
@@ -116,12 +116,12 @@ bool Klient::sende(const char* nachricht, int len) // sendet zum Server
     return 1;
 }
 
-bool Klient::getNachricht(char* nachricht, int len) // empfängt Nachricht
+bool Client::getMessage(char* message, int len) // receives message
 {
     int ll = 0;
     while (len > 0)
     {
-        int l = (int)recv(sock, nachricht + ll, len, MSG_WAITALL);
+        int l = (int)recv(sock, message + ll, len, MSG_WAITALL);
         if (l <= 0)
         {
 #ifdef WIN32
@@ -131,7 +131,7 @@ bool Klient::getNachricht(char* nachricht, int len) // empf
 #    endif
 #endif
             errorOccured = 1;
-            return 0; // Fehler
+            return 0; // Error
         }
         len -= l;
         ll += l;
@@ -140,11 +140,11 @@ bool Klient::getNachricht(char* nachricht, int len) // empf
     return 1;
 }
 
-bool Klient::sendeEncrypted(const char* nachricht, int len) // sendet zum Server
+bool Client::sendEncrypted(const char* message, int len) // sends to server
 {
-    if (!sendeKey) return sende(nachricht, len);
-    Encryption::Bytes* n = new Encryption::Bytes(nachricht, len);
-    sendeKey->codieren(
+    if (!sendKey) return send(message, len);
+    Encryption::Bytes* n = new Encryption::Bytes(message, len);
+    sendKey->codieren(
         dynamic_cast<Framework::Encryption::Bytes*>(n->getThis()));
     int ll = 0;
     while (len > 0)
@@ -164,7 +164,7 @@ bool Klient::sendeEncrypted(const char* nachricht, int len) // sendet zum Server
 #endif
             n->release();
             errorOccured = 1;
-            return 0; // Fehler
+            return 0; // Error
         }
         len -= l;
         ll += l;
@@ -174,14 +174,14 @@ bool Klient::sendeEncrypted(const char* nachricht, int len) // sendet zum Server
     return 1;
 }
 
-bool Klient::getNachrichtEncrypted(
-    char* nachricht, int len) // empfängt Nachricht
+bool Client::getMessageEncrypted(
+    char* message, int len) // receives message
 {
-    if (!empfangKey) return getNachricht(nachricht, len);
+    if (!receiveKey) return getMessage(message, len);
     int ll = 0;
     while (len > 0)
     {
-        int l = (int)recv(sock, nachricht + ll, len, MSG_WAITALL);
+        int l = (int)recv(sock, message + ll, len, MSG_WAITALL);
         if (l <= 0)
         {
 #ifdef WIN32
@@ -191,55 +191,55 @@ bool Klient::getNachrichtEncrypted(
 #    endif
 #endif
             errorOccured = 1;
-            return 0; // Fehler
+            return 0; // Error
         }
         len -= l;
         ll += l;
     }
     Encryption::Bytes* n = new Encryption::Bytes();
-    n->setBytesZ(nachricht, ll);
-    empfangKey->decodieren(n);
+    n->setBytesZ(message, ll);
+    receiveKey->decodieren(n);
     downStreamBytes += ll;
     return 1;
 }
 
-int Klient::getDownloadBytes(
-    bool reset) // gibt die anzahl von empfangen bytes zurück
+int Client::getDownloadBytes(
+    bool reset) // returns the number of received bytes
 {
     int ret = downStreamBytes;
     if (reset) downStreamBytes = 0;
     return ret;
 }
 
-int Klient::getUploadBytes(
-    bool reset) // gibt die anzahl von versendeter bytes zurück
+int Client::getUploadBytes(
+    bool reset) // returns the number of sent bytes
 {
     int ret = upStreamBytes;
     if (reset) upStreamBytes = 0;
     return ret;
 }
 
-bool Klient::trenne() // Trennt die Verbindung zum Server
+bool Client::disconnect() // Disconnects from server
 {
     if (!sock) return 1;
-    if (sendeKey) sendeKey->setPos(0);
-    if (empfangKey) empfangKey->setPos(0);
-    if (closesocket(sock) < 0) // verbindung Trennen
+    if (sendKey) sendKey->setPos(0);
+    if (receiveKey) receiveKey->setPos(0);
+    if (closesocket(sock) < 0) // disconnect
     {
         errorOccured = 1;
-        return 0; // Fehler
+        return 0; // Error
     }
     sock = 0;
     return 1;
 }
 
 // constant
-bool Klient::hatNachricht(int zeit) // Wartet eine Zeit Lang auf eine Nachricht
+bool Client::hasMessage(int time) // Waits for a message for a given time
 {
     fd_set set;
     FD_ZERO(&set);
     FD_SET(sock, &set);
-    timeval time = {zeit / 1000, zeit};
+    timeval time = {time / 1000, time};
     int result = select(0, &set, 0, 0, &time);
     if (result < 0)
     {
@@ -253,17 +253,17 @@ bool Klient::hatNachricht(int zeit) // Wartet eine Zeit Lang auf eine Nachricht
     return result > 0;
 }
 
-unsigned short Klient::getServerPort() const // gibt den Port zurück
+unsigned short Client::getServerPort() const // returns the port
 {
     return htons(server.sin_port);
 }
 
-const char* Klient::getServerIp() const // gibt die Ip zurück
+const char* Client::getServerIp() const // returns the IP
 {
     return inet_ntoa(server.sin_addr);
 }
 
-bool Klient::waitForNextMessage() const // wartet bis es etwas zu empfangen gibt
+bool Client::waitForNextMessage() const // waits until there is something to receive
 {
     fd_set set;
     int rv = 0;
@@ -301,20 +301,20 @@ bool Klient::waitForNextMessage() const // wartet bis es etwas zu empfangen gibt
             << "recv: " << l << " Error: " << WSAGetLastError();
 #    endif
 #endif
-        return 0; // Fehler
+        return 0; // Error
     }
     return 1;
 }
 
-bool Klient::isConnected()
-    const // gibt true zurück, wenn eine Verbindung besteht
+bool Client::isConnected()
+    const // returns true if a connection exists
 {
     return sock != 0 && !errorOccured;
 }
 
-// Inhalt der SSLKlient Klasse aus Klient.h
-// Konstruktor
-SSLKlient::SSLKlient()
+// Content of the SSLClient class from Client.h
+// Constructor
+SSLClient::SSLClient()
     : ReferenceCounter()
 {
     ctx = SSL_CTX_new(TLS_client_method());
@@ -329,11 +329,11 @@ SSLKlient::SSLKlient()
     connected = 0;
 }
 
-// Destruktor
-SSLKlient::~SSLKlient()
+// Destructor
+SSLClient::~SSLClient()
 {
     if (this->ip) this->ip->release();
-    if (connected) trenne();
+    if (connected) disconnect();
     BIO_free_all(bio);
     SSL_CTX_free(ctx);
 #ifdef WIN32
@@ -341,8 +341,8 @@ SSLKlient::~SSLKlient()
 #endif
 }
 
-bool SSLKlient::verbinde(
-    unsigned short port, const char* ip) // verbindet mit Server
+bool SSLClient::connect(
+    unsigned short port, const char* ip) // connects to server
 {
     this->port = port;
     if (this->ip) this->ip->release();
@@ -352,23 +352,23 @@ bool SSLKlient::verbinde(
     adr += port;
     BIO_set_conn_hostname(bio, (const char*)adr);
     connected = BIO_do_connect(bio) > 0;
-    if (connected && BIO_do_handshake(bio) <= 0) trenne();
+    if (connected && BIO_do_handshake(bio) <= 0) disconnect();
     return connected;
 }
 
-bool SSLKlient::sende(const char* nachricht, int len) // sendet zum Server
+bool SSLClient::send(const char* message, int len) // sends to server
 {
     int ll = 0;
     while (len > 0)
     {
-        int l = SSL_write(ssl, nachricht + ll, len);
+        int l = SSL_write(ssl, message + ll, len);
         if (l <= 0)
         {
 #ifdef _DEBUG
             Framework::Logging::warning()
                 << "SSL_write: " << l << " Error: " << SSL_get_error(ssl, l);
 #endif
-            return 0; // Fehler
+            return 0; // Error
         }
         len -= l;
         ll += l;
@@ -377,20 +377,20 @@ bool SSLKlient::sende(const char* nachricht, int len) // sendet zum Server
     return 1;
 }
 
-bool SSLKlient::getNachricht(char* nachricht, int len) // empfängt Nachricht
+bool SSLClient::getMessage(char* message, int len) // receives message
 {
     if (!connected) return 0;
     int ll = 0;
     while (len > 0)
     {
-        int l = SSL_read(ssl, nachricht + ll, len);
+        int l = SSL_read(ssl, message + ll, len);
         if (l <= 0)
         {
 #ifdef _DEBUG
             Framework::Logging::warning()
                 << "SSL_read: " << l << " Error: " << SSL_get_error(ssl, l);
 #endif
-            return 0; // Fehler
+            return 0; // Error
         }
         len -= l;
         ll += l;
@@ -399,23 +399,23 @@ bool SSLKlient::getNachricht(char* nachricht, int len) // empf
     return 1;
 }
 
-int SSLKlient::getDownloadBytes(
-    bool reset) // gibt die anzahl von empfangen bytes zurück
+int SSLClient::getDownloadBytes(
+    bool reset) // returns the number of received bytes
 {
     int ret = downStreamBytes;
     if (reset) downStreamBytes = 0;
     return ret;
 }
 
-int SSLKlient::getUploadBytes(
-    bool reset) // gibt die anzahl von versendeter bytes zurück
+int SSLClient::getUploadBytes(
+    bool reset) // returns the number of sent bytes
 {
     int ret = upStreamBytes;
     if (reset) upStreamBytes = 0;
     return ret;
 }
 
-bool SSLKlient::trenne() // Trennt die Verbindung zum Server
+bool SSLClient::disconnect() // Disconnects from server
 {
     BIO_ssl_shutdown(bio);
     connected = 0;
@@ -423,23 +423,23 @@ bool SSLKlient::trenne() // Trennt die Verbindung zum Server
 }
 
 // constant
-bool SSLKlient::hatNachricht(
-    int zeit) // Wartet eine Zeit Lang auf eine Nachricht
+bool SSLClient::hasMessage(
+    int time) // Waits for a message for a given time
 {
     fd_set set;
     FD_ZERO(&set);
     FD_SET(SSL_get_rfd(ssl), &set);
-    timeval time = {zeit / 1000, zeit};
+    timeval time = {time / 1000, time};
     return SSL_pending(ssl) > 0 || select(0, &set, 0, 0, &time) == 1;
 }
 
 unsigned short
-SSLKlient::getServerPort() const // gibt den Port des Servers zurück
+SSLClient::getServerPort() const // returns the server port
 {
     return port;
 }
 
-const char* SSLKlient::getServerIp() const // gibt die Ip des Servers zurück
+const char* SSLClient::getServerIp() const // returns the server IP
 {
     return ip->getText();
 }

Network/Client.h

@@ -0,0 +1,126 @@
+#ifndef Client_H
+#define Client_H
+
+#include <ReferenceCounter.h>
+
+#include "Network.h"
+
+#ifdef INCLUDE_SSL
+#    include <openssl/bio.h>
+#    include <openssl/ssl.h>
+#else
+struct SSL_CTX;
+struct SSL;
+struct BIO;
+#endif
+
+namespace Framework
+{
+    namespace Encryption
+    {
+        class Key;
+    }
+
+    class Text;
+} // namespace Framework
+
+using namespace Framework;
+
+namespace Network
+{
+    class Client; // from this file
+
+    class Client : public EncryptedConnection,
+                   public virtual ReferenceCounter
+    {
+    private:
+        SOCKET sock;
+        sockaddr_in server;
+        Encryption::Key* sendKey;
+        Encryption::Key* receiveKey;
+        int downStreamBytes;
+        int upStreamBytes;
+        bool errorOccured;
+
+    public:
+        // Constructor
+        __declspec(dllexport) Client();
+        // Destructor
+        __declspec(dllexport) ~Client();
+        // non-constant
+        __declspec(dllexport) void setSendKeyZ(
+            Encryption::Key* key); // Sets the key for sending
+        __declspec(dllexport) void setReceiveKeyZ(
+            Encryption::Key* key); // Sets the key for receiving
+        __declspec(dllexport) void setSendKey(
+            const char* key, int len); // Sets the key for sending
+        __declspec(dllexport) void setReceiveKey(
+            const char* key, int len); // Sets the key for receiving
+        __declspec(dllexport) bool connect(
+            unsigned short port, const char* ip); // connects to server
+        __declspec(dllexport) bool send(
+            const char* message, int len) override; // sends to server
+        __declspec(dllexport) bool getMessage(
+            char* message, int len) override; // receives message
+        __declspec(dllexport) bool sendEncrypted(
+            const char* message, int len) override; // sends to server
+        __declspec(dllexport) bool getMessageEncrypted(
+            char* message, int len) override; // receives message
+        __declspec(dllexport) int getDownloadBytes(
+            bool reset); // returns the number of received bytes
+        __declspec(dllexport) int getUploadBytes(
+            bool reset); // returns the number of sent bytes
+        __declspec(dllexport) bool disconnect(); // Disconnects from server
+        // constant
+        __declspec(dllexport) bool hasMessage(
+            int time); // Waits for a message for a given time
+        __declspec(dllexport) unsigned short
+        getServerPort() const; // returns the server port
+        __declspec(dllexport) const char*
+        getServerIp() const; // returns the server IP
+        __declspec(dllexport) bool
+        waitForNextMessage() const; // waits until there is something to receive
+        __declspec(dllexport) bool
+        isConnected() const; // returns true if a connection exists
+    };
+
+    class SSLClient : public Connection,
+                      public virtual ReferenceCounter
+    {
+    private:
+        unsigned short port;
+        Text* ip;
+        SSL_CTX* ctx;
+        SSL* ssl;
+        BIO* bio;
+        int downStreamBytes;
+        int upStreamBytes;
+        bool connected;
+
+    public:
+        // Constructor
+        __declspec(dllexport) SSLClient();
+        // Destructor
+        __declspec(dllexport) ~SSLClient();
+        __declspec(dllexport) bool connect(
+            unsigned short port, const char* ip); // connects to server
+        __declspec(dllexport) bool send(
+            const char* message, int len) override; // sends to server
+        __declspec(dllexport) bool getMessage(
+            char* message, int len) override; // receives message
+        __declspec(dllexport) int getDownloadBytes(
+            bool reset); // returns the number of received bytes
+        __declspec(dllexport) int getUploadBytes(
+            bool reset); // returns the number of sent bytes
+        __declspec(dllexport) bool disconnect(); // Disconnects from server
+        // constant
+        __declspec(dllexport) bool hasMessage(
+            int time); // Waits for a message for a given time
+        __declspec(dllexport) unsigned short
+        getServerPort() const; // returns the server port
+        __declspec(dllexport) const char*
+        getServerIp() const; // returns the server IP
+    };
+} // namespace Network
+
+#endif

Network/HttpRequest.cpp

@@ -1,9 +1,9 @@
 #include "HttpRequest.h"
 
 #include <iostream>
-#include <Zeit.h>
+#include <Timer.h>
 
-#include "Klient.h"
+#include "Client.h"
 
 using namespace Framework;
 using namespace Network;
@@ -38,17 +38,17 @@ Answer* PostRequest::execute() const
     message += data.getLength();
     message += "\r\n\r\n";
     message += data;
-    SSLKlient httpsK;
-    Klient httpK;
+    SSLClient httpsK;
+    Client httpK;
     if (useSSL)
     {
-        if (!httpsK.verbinde(port, host)) return 0;
-        httpsK.sende(message, message.getLength());
+        if (!httpsK.connect(port, host)) return 0;
+        httpsK.send(message, message.getLength());
     }
     else
     {
-        if (!httpK.verbinde(port, host)) return 0;
-        httpK.sende(message, message.getLength());
+        if (!httpK.connect(port, host)) return 0;
+        httpK.send(message, message.getLength());
     }
     int length = -1;
     bool lastn = 0;
@@ -57,35 +57,35 @@ Answer* PostRequest::execute() const
     {
         char buff[2];
         buff[1] = 0;
-        if ((useSSL && httpsK.getNachricht(buff, 1))
-            || (!useSSL && httpK.getNachricht(buff, 1)))
+        if ((useSSL && httpsK.getMessage(buff, 1))
+            || (!useSSL && httpK.getMessage(buff, 1)))
         {
             answer += buff;
             if (buff[0] == '\n')
             {
                 if (length <= 0)
                 {
-                    int p = answer.positionVon("Content-Length: ");
+                    int p = answer.positionOf("Content-Length: ");
                     if (p >= 0)
                     {
                         p += 16;
                         Text* len = answer.getTeilText(p);
-                        len->remove(len->positionVon("\n"), len->getLength());
+                        len->remove(len->positionOf("\n"), len->getLength());
                         len->remove("\r");
                         length = (int)*len;
                         len->release();
                     }
                 }
                 else if (lastn)
-                { // header der antwort ist vorbei
+                { // header of the response is done
                     char* buff = new char[length + 1];
                     buff[length] = 0;
                     if (length > 0)
                     {
                         if (useSSL)
-                            httpsK.getNachricht(buff, length);
+                            httpsK.getMessage(buff, length);
                         else
-                            httpK.getNachricht(buff, length);
+                            httpK.getMessage(buff, length);
                     }
                     answer += buff;
                     delete[] buff;
@@ -98,8 +98,8 @@ Answer* PostRequest::execute() const
         }
         else
             break;
-    } while ((useSSL && httpsK.hatNachricht(1000))
-             || (!useSSL && httpK.hatNachricht(1000)));
+    } while ((useSSL && httpsK.hasMessage(1000))
+             || (!useSSL && httpK.hasMessage(1000)));
     if (answer.getLength()) return new Answer(answer);
     return 0;
 }
@@ -110,26 +110,26 @@ Answer::Answer(const char* answer)
     all = answer;
     TextReader reader(new Text(answer));
     // parse header
-    Text* line = reader.leseZeile();
+    Text* line = reader.readLine();
     line->remove("\r\n");
     line->remove("\n");
     header += *line;
     header += "\n";
-    int trenn = line->positionVon(" ");
+    int trenn = line->positionOf(" ");
     Text* tmp = line->getTeilText(0, trenn);
     this->protocol = *tmp;
     tmp->release();
     line->remove(0, trenn + 1);
-    trenn = line->positionVon(" ");
+    trenn = line->positionOf(" ");
     tmp = line->getTeilText(0, trenn);
     this->statusNumber = (int)*tmp;
     tmp->release();
     line->remove(0, trenn + 1);
     this->statusText = *line;
     line->release();
-    while (!reader.istEnde())
+    while (!reader.isEnd())
     {
-        Text* line = reader.leseZeile();
+        Text* line = reader.readLine();
         line->remove("\r\n");
         line->remove("\n");
         if (line->getLength() > 0)
@@ -137,15 +137,15 @@ Answer::Answer(const char* answer)
             header += *line;
             header += "\n";
         }
-        if (line->positionVon("Date:") == 0) this->date = line->getText() + 6;
-        if (line->positionVon("Content-Type:") == 0)
+        if (line->positionOf("Date:") == 0) this->date = line->getText() + 6;
+        if (line->positionOf("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();
+    if (!reader.isEnd()) this->data = answer + reader.getLPosition();
 }
 
 const char* Answer::getContentType() const

Network/Klient.h

@@ -1,126 +0,0 @@
-#ifndef Klient_H
-#define Klient_H
-
-#include <ReferenceCounter.h>
-
-#include "Network.h"
-
-#ifdef INCLUDE_SSL
-#    include <openssl/bio.h>
-#    include <openssl/ssl.h>
-#else
-struct SSL_CTX;
-struct SSL;
-struct BIO;
-#endif
-
-namespace Framework
-{
-    namespace Encryption
-    {
-        class Key;
-    }
-
-    class Text;
-} // namespace Framework
-
-using namespace Framework;
-
-namespace Network
-{
-    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;
-        bool errorOccured;
-
-    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
-        __declspec(dllexport) bool isConnected()
-            const; // gibt true zurück, wenn eine Verbindung besteht
-    };
-
-    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
-    };
-} // namespace Network
-
-#endif

Network/Network.cpp

@@ -1,4 +1,4 @@
-#include "Network.h"
+#include "Network.h"
 #ifndef WIN32
 #    include <iostream>
 #    include <netdb.h>
@@ -10,16 +10,16 @@
 #include <openssl/ssl.h>
 #include <Text.h>
 
-// Starte Netzwerk
+// Start network
 void Network::Start(int maxClients)
 {
 #ifdef WIN32
     WSADATA lpwd;
     lpwd.iMaxSockets = maxClients;
-    int fehler = WSAStartup(MAKEWORD(2, 0), &lpwd);
-    if (fehler != 0)
+    int error = WSAStartup(MAKEWORD(2, 0), &lpwd);
+    if (error != 0)
         Framework::Logging::error()
-            << "Could not initialize Win Sock 2.0 WSAStartup: " << fehler;
+            << "Could not initialize Win Sock 2.0 WSAStartup: " << error;
 #else
     signal(SIGPIPE, SIG_IGN);
 #endif
@@ -33,9 +33,9 @@ void Network::getHostName(char* name, int bufferLen)
     gethostname(name, bufferLen);
 }
 
-char* Network::getHostAddresse()
+char* Network::getHostAddress()
 {
-    char* addresse;
+    char* address;
     char name[255] = "";
     getHostName(name, 255);
     PHOSTENT hostinfo;
@@ -46,11 +46,11 @@ char* Network::getHostAddresse()
             << "The ip address of host '" << name << "' could not be resolved";
         return 0;
     }
-    addresse = inet_ntoa(*(struct in_addr*)*hostinfo->h_addr_list);
-    return addresse;
+    address = inet_ntoa(*(struct in_addr*)*hostinfo->h_addr_list);
+    return address;
 }
 
-// Beende Netzwerk
+// Stop network
 void Network::Exit()
 {
 #ifdef WIN32
@@ -58,24 +58,24 @@ void Network::Exit()
 #endif
 }
 
-Network::NetworkReader::NetworkReader(Verbindung* v)
+Network::NetworkReader::NetworkReader(Connection* v)
 {
-    verbindung = v;
+    connection = v;
 }
 
 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)
+//! Reads from the resource
+//! \param bytes An array to be filled with bytes from the resource
+//! \param len How many bytes to read from the resource
+void Network::NetworkReader::read(char* bytes, int len)
 {
-    verbindung->getNachricht(bytes, len);
+    connection->getMessage(bytes, len);
 }
 
-//! Ließt die nächste zeile der Resource ein
-//! \return Die gelesene Zeile als Text mit zeilenumbruch
-Framework::Text* Network::NetworkReader::leseZeile()
+//! Reads the next line from the resource
+//! \return The read line as text with line break
+Framework::Text* Network::NetworkReader::readLine()
 {
     int maxLength = 2048;
     char* buffer = new char[maxLength];
@@ -83,7 +83,7 @@ Framework::Text* Network::NetworkReader::leseZeile()
     int index = 0;
     do
     {
-        verbindung->getNachricht(&b, 1);
+        connection->getMessage(&b, 1);
         buffer[index++] = b;
         if (index == maxLength)
         {
@@ -100,52 +100,51 @@ Framework::Text* Network::NetworkReader::leseZeile()
     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
+//! Checks whether the resource has been fully read
+//!  return 1 if the resource has been fully read. 0 otherwise
+bool Network::NetworkReader::isEnd() const
 {
     return 0;
 }
 
-Network::NetworkWriter::NetworkWriter(Verbindung* v)
+Network::NetworkWriter::NetworkWriter(Connection* v)
 {
-    verbindung = v;
+    connection = v;
 }
 
 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)
+//! Writes to the resource
+//! \param bytes An array containing the bytes to write to the resource
+//! \param len How many bytes to write to the resource
+void Network::NetworkWriter::write(const char* bytes, int len)
 {
-    verbindung->sende(bytes, len);
+    connection->send(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
+//! Checks whether the resource has been fully written
+//!  return 1 if the resource has been fully written. 0 otherwise
+bool Network::NetworkWriter::isEnd() const
 {
     return 0;
 }
 
-Network::EncryptedNetworkReader::EncryptedNetworkReader(EncryptedVerbindung* v)
+Network::EncryptedNetworkReader::EncryptedNetworkReader(EncryptedConnection* v)
 {
-    verbindung = v;
+    connection = 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)
+//! Reads from the resource
+//! \param bytes An array to be filled with bytes from the resource
+//! \param len How many bytes to read from the resource
+void Network::EncryptedNetworkReader::read(char* bytes, int len)
 {
-    verbindung->getNachrichtEncrypted(bytes, len);
+    connection->getMessageEncrypted(bytes, len);
 }
 
-//! Ließt die nächste zeile der Resource ein
-//! \return Die gelesene Zeile als Text mit zeilenumbruch
-Framework::Text* Network::EncryptedNetworkReader::leseZeile()
+//! Reads the next line from the resource
+//! \return The read line as text with line break
+Framework::Text* Network::EncryptedNetworkReader::readLine()
 {
     int maxLength = 2048;
     char* buffer = new char[maxLength];
@@ -153,7 +152,7 @@ Framework::Text* Network::EncryptedNetworkReader::leseZeile()
     int index = 0;
     do
     {
-        verbindung->getNachrichtEncrypted(&b, 1);
+        connection->getMessageEncrypted(&b, 1);
         buffer[index++] = b;
         if (index == maxLength)
         {
@@ -170,30 +169,29 @@ Framework::Text* Network::EncryptedNetworkReader::leseZeile()
     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
+//! Checks whether the resource has been fully read
+//!  return 1 if the resource has been fully read. 0 otherwise
+bool Network::EncryptedNetworkReader::isEnd() const
 {
     return 0;
 }
 
-Network::EncryptedNetworkWriter::EncryptedNetworkWriter(EncryptedVerbindung* v)
+Network::EncryptedNetworkWriter::EncryptedNetworkWriter(EncryptedConnection* v)
 {
-    verbindung = v;
+    connection = 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)
+//! Writes to the resource
+//! \param bytes An array containing the bytes to write to the resource
+//! \param len How many bytes to write to the resource
+void Network::EncryptedNetworkWriter::write(const char* bytes, int len)
 {
-    verbindung->sendeEncrypted(bytes, len);
+    connection->sendEncrypted(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
+//! Checks whether the resource has been fully written
+//!  return 1 if the resource has been fully written. 0 otherwise
+bool Network::EncryptedNetworkWriter::isEnd() const
 {
     return 0;
 }

Network/Network.h

@@ -44,103 +44,97 @@ namespace Network
 {
     __declspec(dllexport) void Start(int maxClients);
     __declspec(dllexport) void getHostName(char* name, int bufferLen);
-    __declspec(dllexport) char* getHostAddresse();
+    __declspec(dllexport) char* getHostAddress();
     __declspec(dllexport) void Exit();
 
-    class Verbindung
+    class Connection
     {
     public:
-        virtual bool sende(const char* nachricht, int len)
-            = 0; // sendet Nachricht
-        virtual bool getNachricht(char* nachricht, int len)
-            = 0; // empfängt Nachricht
+        virtual bool send(const char* message, int len)
+            = 0; // sends message
+        virtual bool getMessage(char* message, int len)
+            = 0; // receives message
     };
 
-    class EncryptedVerbindung : public Verbindung
+    class EncryptedConnection : public Connection
     {
     public:
-        virtual bool sendeEncrypted(const char* nachricht, int len)
-            = 0; // sendet Nachricht
-        virtual bool getNachrichtEncrypted(char* nachricht, int len)
-            = 0; // empfängt Nachricht
+        virtual bool sendEncrypted(const char* message, int len)
+            = 0; // sends message
+        virtual bool getMessageEncrypted(char* message, int len)
+            = 0; // receives message
     };
 
     class NetworkReader : public Framework::StreamReader
     {
     private:
-        Verbindung* verbindung;
+        Connection* connection;
 
     public:
-        __declspec(dllexport) NetworkReader(Verbindung* v);
+        __declspec(dllexport) NetworkReader(Connection* 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;
+        //! Reads from the resource
+        //! \param bytes An array to be filled with bytes from the resource
+        //! \param len How many bytes to read from the resource
+        __declspec(dllexport) void read(char* bytes, int len) override;
+        //! Reads the next line from the resource
+        //! \return The read line as text with line break
+        __declspec(dllexport) Framework::Text* readLine() override;
+        //! Checks whether the resource has been fully read
+        //!  return 1 if the resource has been fully read. 0 otherwise
+        __declspec(dllexport) bool isEnd() const override;
     };
 
     class NetworkWriter : public Framework::StreamWriter
     {
     private:
-        Verbindung* verbindung;
+        Connection* connection;
 
     public:
-        __declspec(dllexport) NetworkWriter(Verbindung* v);
+        __declspec(dllexport) NetworkWriter(Connection* 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;
+        //! Writes to the resource
+        //! \param bytes An array containing the bytes to write to the resource
+        //! \param len How many bytes to write to the resource
+        __declspec(dllexport) void write(const char* bytes, int len) override;
+        //! Checks whether the resource has been fully written
+        //!  return 1 if the resource has been fully written. 0 otherwise
+        __declspec(dllexport) bool isEnd() const override;
     };
 
     class EncryptedNetworkReader : public Framework::StreamReader
     {
     private:
-        EncryptedVerbindung* verbindung;
+        EncryptedConnection* connection;
 
     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;
+        __declspec(dllexport) EncryptedNetworkReader(EncryptedConnection* v);
+        //! Reads from the resource
+        //! \param bytes An array to be filled with bytes from the resource
+        //! \param len How many bytes to read from the resource
+        __declspec(dllexport) void read(char* bytes, int len) override;
+        //! Reads the next line from the resource
+        //! \return The read line as text with line break
+        __declspec(dllexport) Framework::Text* readLine() override;
+        //! Checks whether the resource has been fully read
+        //!  return 1 if the resource has been fully read. 0 otherwise
+        __declspec(dllexport) bool isEnd() const override;
     };
 
     class EncryptedNetworkWriter : public Framework::StreamWriter
     {
     private:
-        EncryptedVerbindung* verbindung;
+        EncryptedConnection* connection;
 
     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;
+        __declspec(dllexport) EncryptedNetworkWriter(EncryptedConnection* v);
+        //! Writes to the resource
+        //! \param bytes An array containing the bytes to write to the resource
+        //! \param len How many bytes to write to the resource
+        __declspec(dllexport) void write(const char* bytes, int len) override;
+        //! Checks whether the resource has been fully written
+        //!  return 1 if the resource has been fully written. 0 otherwise
+        __declspec(dllexport) bool isEnd() const override;
     };
 } // namespace Network
 

Network/Network.vcxproj

@@ -22,34 +22,34 @@
     <ProjectGuid>{E52010A0-0060-42AA-9769-AAF6488F8C1C}</ProjectGuid>
     <Keyword>Win32Proj</Keyword>
     <RootNamespace>Network</RootNamespace>
-    <WindowsTargetPlatformVersion>10.0.19041.0</WindowsTargetPlatformVersion>
+    <WindowsTargetPlatformVersion>10.0</WindowsTargetPlatformVersion>
   </PropertyGroup>
   <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration">
     <ConfigurationType>DynamicLibrary</ConfigurationType>
     <UseDebugLibraries>true</UseDebugLibraries>
     <CharacterSet>Unicode</CharacterSet>
-    <PlatformToolset>v143</PlatformToolset>
+    <PlatformToolset>v145</PlatformToolset>
   </PropertyGroup>
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="Configuration">
     <ConfigurationType>DynamicLibrary</ConfigurationType>
     <UseDebugLibraries>true</UseDebugLibraries>
     <CharacterSet>MultiByte</CharacterSet>
-    <PlatformToolset>v143</PlatformToolset>
+    <PlatformToolset>v145</PlatformToolset>
   </PropertyGroup>
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="Configuration">
     <ConfigurationType>DynamicLibrary</ConfigurationType>
     <UseDebugLibraries>false</UseDebugLibraries>
     <WholeProgramOptimization>true</WholeProgramOptimization>
     <CharacterSet>MultiByte</CharacterSet>
-    <PlatformToolset>v143</PlatformToolset>
+    <PlatformToolset>v145</PlatformToolset>
   </PropertyGroup>
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="Configuration">
     <ConfigurationType>DynamicLibrary</ConfigurationType>
     <UseDebugLibraries>false</UseDebugLibraries>
     <WholeProgramOptimization>true</WholeProgramOptimization>
     <CharacterSet>MultiByte</CharacterSet>
-    <PlatformToolset>v143</PlatformToolset>
+    <PlatformToolset>v145</PlatformToolset>
   </PropertyGroup>
   <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
   <ImportGroup Label="ExtensionSettings">
@@ -180,14 +180,14 @@ copy "..\x64\Release\Network.dll" "..\..\..\Spiele Platform\SMP\Fertig\x64\netwo
   </ItemDefinitionGroup>
   <ItemGroup>
     <ClInclude Include="HttpRequest.h" />
-    <ClInclude Include="Klient.h" />
+    <ClInclude Include="Client.h" />
     <ClInclude Include="Network.h" />
     <ClInclude Include="Server.h" />
     <ClInclude Include="WebSocket.h" />
   </ItemGroup>
   <ItemGroup>
     <ClCompile Include="HttpRequest.cpp" />
-    <ClCompile Include="Klient.cpp" />
+    <ClCompile Include="Client.cpp" />
     <ClCompile Include="Network.cpp" />
     <ClCompile Include="Server.cpp" />
     <ClCompile Include="WebSocket.cpp" />

Network/Network.vcxproj.filters

@@ -21,23 +21,20 @@
     <ClInclude Include="Server.h">
       <Filter>Headerdateien</Filter>
     </ClInclude>
-    <ClInclude Include="Klient.h">
-      <Filter>Headerdateien</Filter>
-    </ClInclude>
     <ClInclude Include="HttpRequest.h">
       <Filter>Headerdateien</Filter>
     </ClInclude>
     <ClInclude Include="WebSocket.h">
       <Filter>Headerdateien</Filter>
     </ClInclude>
+    <ClInclude Include="Client.h">
+      <Filter>Headerdateien</Filter>
+    </ClInclude>
   </ItemGroup>
   <ItemGroup>
     <ClCompile Include="Server.cpp">
       <Filter>Quelldateien</Filter>
     </ClCompile>
-    <ClCompile Include="Klient.cpp">
-      <Filter>Quelldateien</Filter>
-    </ClCompile>
     <ClCompile Include="Network.cpp">
       <Filter>Quelldateien</Filter>
     </ClCompile>
@@ -47,5 +44,8 @@
     <ClCompile Include="WebSocket.cpp">
       <Filter>Quelldateien</Filter>
     </ClCompile>
+    <ClCompile Include="Client.cpp">
+      <Filter>Quelldateien</Filter>
+    </ClCompile>
   </ItemGroup>
 </Project>

Network/Server.cpp

@@ -12,30 +12,29 @@
 
 using namespace Network;
 
-// Inhalt der Server Klasse aus Server.h
-// Konstruktor
+// Content of the Server class from Server.h
+// Constructor
 Server::Server()
     : ReferenceCounter()
 {
     sock = 0;
-    memset(&addresse, 0, sizeof(addresse)); // Adresse setzen
-    addresse.sin_family = AF_INET;
-    addresse.sin_addr.s_addr = ADDR_ANY;
-    klients = 0;
+    memset(&address, 0, sizeof(address)); // Set address
+    address.sin_family = AF_INET;
+    address.sin_addr.s_addr = ADDR_ANY;
+    clients = 0;
 }
 
-// Destruktor
+// Destructor
 Server::~Server()
 {
-    trenne();
+    disconnect();
 }
 
-// nicht constant
-bool Server::verbinde(
-    unsigned short port, int warteschlangenLen) // Öffnet das Socket
+// non-constant
+bool Server::connect(unsigned short port, int queueLength) // Opens the socket
 {
-    sock = socket(AF_INET, SOCK_STREAM, 0); // Socket erstellen
-    addresse.sin_port = htons(port);        // port setzen
+    sock = socket(AF_INET, SOCK_STREAM, 0); // Create socket
+    address.sin_port = htons(port);        // set port
     if (sock < 0)
     {
         sock = 0;
@@ -48,25 +47,25 @@ bool Server::verbinde(
     int reuseSocket = 1;
     setsockopt(sock, SOL_SOCKET, SO_REUSEADDR, &reuseSocket, sizeof(int));
 #endif
-    if (bind(sock, (struct sockaddr*)&addresse, sizeof(addresse))
-        == -1) // socket öffnen
+    if (bind(sock, (struct sockaddr*)&address, sizeof(address))
+        == -1) // open socket
     {
-        trenne();
-        return 0; // Fehler
+        disconnect();
+        return 0; // Error
     }
-    if (listen(sock, warteschlangenLen) == -1) // Klients annehmen
+    if (listen(sock, queueLength) == -1) // accept clients
     {
-        trenne();
-        return 0; // Fehler
+        disconnect();
+        return 0; // Error
     }
     return 1;
 }
 
-SKlient* Server::getKlient() // nimmt Klient an
+SClient* Server::getClient() // accepts a client
 {
     if (!sock) return 0;
     sockaddr_in client;
-    int len = sizeof(addresse);
+    int len = sizeof(address);
     fd_set set;
     int rv = 0;
     struct timeval timeout;
@@ -81,78 +80,78 @@ SKlient* Server::getKlient() // nimmt Klient an
     }
     if (!sock) return 0;
 #ifdef WIN32
-    SOCKET cls = accept(sock, (sockaddr*)&client, &len); // Klient empfangen
+    SOCKET cls = accept(sock, (sockaddr*)&client, &len); // receive client
     if (cls == INVALID_SOCKET)
     {
-        trenne();
+        disconnect();
         return 0;
     }
 #else
     SOCKET cls = accept(
-        sock, (sockaddr*)&client, (socklen_t*)&len); // Klient empfangen
+        sock, (sockaddr*)&client, (socklen_t*)&len); // receive client
     if (!cls)
     {
-        if (errno == ECONNABORTED || errno == EBADF) trenne();
+        if (errno == ECONNABORTED || errno == EBADF) disconnect();
         return 0;
     }
 #endif
-    client.sin_port = addresse.sin_port;
-    klients++;
-    return new SKlient(client, cls); // Klient Handle Klasse zurückgeben
+    client.sin_port = address.sin_port;
+    clients++;
+    return new SClient(client, cls); // return client handle class
 }
 
-int Server::getKlients(bool reset) // gibt die Anzahl der Klients zurück
+int Server::getClients(bool reset) // returns the number of clients
 {
-    int ret = klients;
-    if (reset) klients = 0;
+    int ret = clients;
+    if (reset) clients = 0;
     return ret;
 }
 
-bool Server::trenne() // beendet den Server
+bool Server::disconnect() // stops the server
 {
     if (!sock) return 1;
-    if (closesocket(sock) < 0) // socket schließen
+    if (closesocket(sock) < 0) // close socket
         return 0;
     sock = 0;
     return 1;
 }
 
 // constant
-unsigned short Server::getPort() const // gibt den Port zurück
+unsigned short Server::getPort() const // returns the port
 {
-    return htons(addresse.sin_port);
+    return htons(address.sin_port);
 }
 
 bool Server::isConnected()
-    const // giebt 1 zurück, falls der Server verbunden ist
+    const // returns 1 if the server is connected
 {
     return sock != 0;
 }
 
-// Inhalt der SKlient Klasse aus Server.h
-// Konstruktor
-SKlient::SKlient(sockaddr_in addresse, SOCKET sock)
+// Content of the SClient class from Server.h
+// Constructor
+SClient::SClient(sockaddr_in address, SOCKET sock)
     : ReferenceCounter()
 {
-    clientAddr = addresse;
+    clientAddr = address;
     this->sock = sock;
     downStreamBytes = 0;
     upStreamBytes = 0;
-    sendeKey = 0;
-    empfangKey = 0;
+    sendKey = 0;
+    receiveKey = 0;
 }
 
-// Destruktor
-SKlient::~SKlient()
+// Destructor
+SClient::~SClient()
 {
-    trenne();
-    if (sendeKey) sendeKey->release();
-    if (empfangKey) empfangKey->release();
+    disconnect();
+    if (sendKey) sendKey->release();
+    if (receiveKey) receiveKey->release();
 }
 
-// nicht constant
-void SKlient::setEmpfangTimeout(
-    int miliseconds) // Setzt ein timeout fürs empfangen von daten
+// non-constant
+void SClient::setReceiveTimeout(
+    int miliseconds) // Sets a timeout for receiving data
 {
 #ifdef WIN32
     DWORD timeout = miliseconds;
@@ -166,42 +165,42 @@ void SKlient::setEmpfangTimeout(
 #endif
 }
 
-void SKlient::setSendeKeyZ(Encryption::Key* key) // Setzt den Key fürs Senden
+void SClient::setSendKeyZ(Encryption::Key* key) // Sets the key for sending
 {
-    if (sendeKey) sendeKey->release();
-    sendeKey = key;
+    if (sendKey) sendKey->release();
+    sendKey = key;
 }
 
-void SKlient::setEmpfangKeyZ(
-    Encryption::Key* key) // Setzt den Key fürs Empfangen
+void SClient::setReceiveKeyZ(
+    Encryption::Key* key) // Sets the key for receiving
 {
-    if (empfangKey) empfangKey->release();
-    empfangKey = key;
+    if (receiveKey) receiveKey->release();
+    receiveKey = key;
 }
 
-void SKlient::setSendeKey(const char* key, int len) // Setzt den Key fürs Senden
+void SClient::setSendKey(const char* key, int len) // Sets the key for sending
 {
-    if (!sendeKey) sendeKey = new Encryption::Key();
-    sendeKey->setKey(key, len);
+    if (!sendKey) sendKey = new Encryption::Key();
+    sendKey->setKey(key, len);
 }
 
-void SKlient::setEmpfangKey(
-    const char* key, int len) // Setzt den Key fürs Empfangen
+void SClient::setReceiveKey(
+    const char* key, int len) // Sets the key for receiving
 {
-    if (!empfangKey) empfangKey = new Encryption::Key();
-    empfangKey->setKey(key, len);
+    if (!receiveKey) receiveKey = new Encryption::Key();
+    receiveKey->setKey(key, len);
 }
 
-bool SKlient::sende(const char* nachricht, int len) // sendet zum Klient
+bool SClient::send(const char* message, int len) // sends to client
 {
     if (!sock) return 0;
     int ll = 0;
     while (len > 0)
     {
 #ifdef WIN32
-        int l = send(sock, nachricht + ll, len, 0);
+        int l = send(sock, message + ll, len, 0);
 #else
-        int l = (int)send(sock, nachricht + ll, len, MSG_NOSIGNAL);
+        int l = (int)send(sock, message + ll, len, MSG_NOSIGNAL);
 #endif
         if (l <= 0)
         {
@@ -211,7 +210,7 @@ bool SKlient::sende(const char* nachricht, int len) // sendet zum Klient
                 << "send: " << l << " Error: " << WSAGetLastError();
 #    endif
 #endif
-            return 0; // Fehler
+            return 0; // Error
         }
         len -= l;
         ll += l;
@@ -220,14 +219,13 @@ bool SKlient::sende(const char* nachricht, int len) // sendet zum Klient
     return 1;
 }
 
-bool SKlient::getNachricht(
-    char* nachricht, int len) // empfängt Nachricht von Klient
+bool SClient::getMessage(char* message, int len) // receives message from client
 {
     if (!sock) return 0;
     int ll = 0;
     while (len > 0)
     {
-        int l = (int)recv(sock, nachricht + ll, len, MSG_WAITALL);
+        int l = (int)recv(sock, message + ll, len, MSG_WAITALL);
         if (l <= 0)
         {
 #ifdef WIN32
@@ -236,7 +234,7 @@ bool SKlient::getNachricht(
                 << "recv: " << l << " Error: " << WSAGetLastError();
 #    endif
 #endif
-            return 0; // Fehler
+            return 0; // Error
         }
         len -= l;
         ll += l;
@@ -245,12 +243,11 @@ bool SKlient::getNachricht(
     return 1;
 }
 
-bool SKlient::sendeEncrypted(
-    const char* nachricht, int len) // sendet zum Server
+bool SClient::sendEncrypted(const char* message, int len) // sends to server
 {
-    if (!sendeKey) return sende(nachricht, len);
-    Encryption::Bytes* n = new Encryption::Bytes(nachricht, len);
-    sendeKey->codieren(dynamic_cast<Encryption::Bytes*>(n->getThis()));
+    if (!sendKey) return send(message, len);
+    Encryption::Bytes* n = new Encryption::Bytes(message, len);
+    sendKey->codieren(dynamic_cast<Encryption::Bytes*>(n->getThis()));
     int ll = 0;
     while (len > 0)
     {
@@ -268,7 +265,7 @@ bool SKlient::sendeEncrypted(
 #    endif
 #endif
             n->release();
-            return 0; // Fehler
+            return 0; // Error
         }
         len -= l;
         ll += l;
@@ -278,14 +275,13 @@ bool SKlient::sendeEncrypted(
     return 1;
 }
 
-bool SKlient::getNachrichtEncrypted(
-    char* nachricht, int len) // empfängt Nachricht
+bool SClient::getMessageEncrypted(char* message, int len) // receives message
 {
-    if (!empfangKey) return getNachricht(nachricht, len);
+    if (!receiveKey) return getMessage(message, len);
     int ll = 0;
     while (len > 0)
     {
-        int l = (int)recv(sock, nachricht + ll, len, MSG_WAITALL);
+        int l = (int)recv(sock, message + ll, len, MSG_WAITALL);
         if (l <= 0)
         {
 #ifdef WIN32
@@ -294,51 +290,51 @@ bool SKlient::getNachrichtEncrypted(
                 << "recv: " << l << " Error: " << WSAGetLastError();
 #    endif
 #endif
-            return 0; // Fehler
+            return 0; // Error
         }
         len -= l;
         ll += l;
     }
     Encryption::Bytes* n = new Encryption::Bytes();
-    n->setBytesZ(nachricht, ll);
-    empfangKey->decodieren(n);
+    n->setBytesZ(message, ll);
+    receiveKey->decodieren(n);
     downStreamBytes += ll;
     return 1;
 }
 
-int SKlient::getDownloadBytes(
-    bool reset) // gibt die anzahl von empfangen bytes zurück
+int SClient::getDownloadBytes(
+    bool reset) // returns the number of received bytes
 {
     int ret = downStreamBytes;
     if (reset) downStreamBytes = 0;
     return ret;
 }
 
-int SKlient::getUploadBytes(
-    bool reset) // gibt die anzahl von versendeter bytes zurück
+int SClient::getUploadBytes(
+    bool reset) // returns the number of sent bytes
 {
     int ret = upStreamBytes;
     if (reset) upStreamBytes = 0;
     return ret;
 }
 
-bool SKlient::trenne() // trennt die Verbindung zum Klient
+bool SClient::disconnect() // disconnects from client
 {
     if (!sock) return 0;
-    if (closesocket(sock) < 0) // trennen
+    if (closesocket(sock) < 0) // disconnect
         return 0;
     sock = 0;
     return 1;
 }
 
 // constant
-bool SKlient::hatNachricht(
-    int zeit) const // Wartet eine Zeit Lang auf eine Nachricht
+bool SClient::hasMessage(
+    int time) const // Waits for a message for a given time
 {
     fd_set set;
     FD_ZERO(&set);
     FD_SET(sock, &set);
-    timeval time = {zeit / 1000, zeit};
+    timeval time = {time / 1000, time};
     int result = select(0, &set, 0, 0, &time);
     if (result < 0)
     {
@@ -352,20 +348,20 @@ bool SKlient::hatNachricht(
     return result > 0;
 }
 
-unsigned short SKlient::getPort() const // gibt den Port zurück
+unsigned short SClient::getPort() const // returns the port
 {
     return htons(clientAddr.sin_port);
 }
 
-const char* SKlient::getIp() const // gibt die Ip des Klients zurück
+const char* SClient::getIp() const // returns the client's IP
 {
     return inet_ntoa(clientAddr.sin_addr);
 }
 
 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));
+    const char* pw = ((Text*)userdata)->getText();
+    memcpy(buf, pw, MIN((unsigned int)size, strlen(pw) + 1));
     return (int)strlen(buf);
 }
 
@@ -395,8 +391,8 @@ bool SSLErrorCheck(__int64 result, const char* action)
     return 1;
 }
 
-bool SKlient::waitForNextMessage()
-    const // wartet bis es etwas zu empfangen gibt
+bool SClient::waitForNextMessage()
+    const // waits until there is something to receive
 {
     fd_set set;
     int rv = 0;
@@ -435,13 +431,13 @@ bool SKlient::waitForNextMessage()
             << "recv: " << l << " Error: " << WSAGetLastError();
 #    endif
 #endif
-        return 0; // Fehler
+        return 0; // Error
     }
     return 1;
 }
 
-// Inhalt der SSLServer Klasse
-// Konstruktor
+// Content of the SSLServer class
+// Constructor
 SSLServer::SSLServer()
     : ReferenceCounter()
 {
@@ -454,26 +450,26 @@ SSLServer::SSLServer()
         "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);
+    password = new Text();
+    SSL_CTX_set_default_passwd_cb_userdata(ctx, password);
     addr.sin_family = AF_INET;
     addr.sin_addr.s_addr = htonl(INADDR_ANY);
-    klients = 0;
+    clients = 0;
 }
 
-// Destruktor
+// Destructor
 SSLServer::~SSLServer()
 {
-    trenne();
+    disconnect();
     SSL_CTX_free(ctx);
-    passw->release();
+    password->release();
 #ifdef WIN32
     OPENSSL_thread_stop();
 #endif
 }
 
-// nicht constant
-// Setzt den Pfad zur Datei, in dem das Certifikat gespeichert ist
+// non-constant
+// Sets the path to the file where the certificate is stored
 bool SSLServer::setCertificateFile(const char* file)
 {
     return SSLErrorCheck(
@@ -481,7 +477,7 @@ bool SSLServer::setCertificateFile(const char* file)
         "SSL_CTX_use_certificate_file");
 }
 
-// Setzt den Pfad zur Datei, in dem der private Schlüssel gespeichert ist
+// Sets the path to the file where the private key is stored
 bool SSLServer::setPrivateKeyFile(const char* file)
 {
     return SSLErrorCheck(
@@ -489,15 +485,15 @@ bool SSLServer::setPrivateKeyFile(const char* file)
         "SSL_CTX_use_PrivateKey_file");
 }
 
-// setzt das passwort des private keys (muss vor setPrivateKeyFile aufgerufen
-// werden)
+// sets the password of the private key (must be called before
+// setPrivateKeyFile)
 void SSLServer::setPrivateKeyPassword(const char* password)
 {
-    passw->setText(password);
+    this->password->setText(password);
 }
 
-// Öffnet das Socket
-bool SSLServer::verbinde(unsigned short port, int warteschlangenLen)
+// Opens the socket
+bool SSLServer::connect(unsigned short port, int queueLength)
 {
     addr.sin_port = htons(port);
     s = socket(AF_INET, SOCK_STREAM, 0);
@@ -515,19 +511,19 @@ bool SSLServer::verbinde(unsigned short port, int warteschlangenLen)
 #endif
     if (bind(s, (struct sockaddr*)&addr, sizeof(addr)) < 0)
     {
-        trenne();
+        disconnect();
         return 0;
     }
-    if (listen(s, warteschlangenLen) < 0)
+    if (listen(s, queueLength) < 0)
     {
-        trenne();
+        disconnect();
         return 0;
     }
     return 1;
 }
 
-// nimmt Klient an
-SSLSKlient* SSLServer::getKlient()
+// accepts a client
+SSLSClient* SSLServer::getClient()
 {
     if (!s) return 0;
     int len = sizeof(addr);
@@ -549,15 +545,15 @@ SSLSKlient* SSLServer::getKlient()
     SOCKET client = accept(s, (struct sockaddr*)&addr, &len);
     if (client == INVALID_SOCKET)
     {
-        trenne();
+        disconnect();
         return 0;
     }
 #else
     SOCKET client
-        = accept(s, (sockaddr*)&addr, (socklen_t*)&len); // Klient empfangen
+        = accept(s, (sockaddr*)&addr, (socklen_t*)&len); // receive client
     if (!client)
     {
-        if (errno == ECONNABORTED || errno == EBADF) trenne();
+        if (errno == ECONNABORTED || errno == EBADF) disconnect();
         return 0;
     }
 #endif
@@ -580,44 +576,44 @@ SSLSKlient* SSLServer::getKlient()
         closesocket(client);
         return 0;
     }
-    klients++;
-    return new SSLSKlient(addr, ssl, client);
+    clients++;
+    return new SSLSClient(addr, ssl, client);
 }
 
-// gibt die Anzahl der Klients zurück
-int SSLServer::getKlients(bool reset)
+// returns the number of clients
+int SSLServer::getClients(bool reset)
 {
-    int ret = klients;
-    if (reset) klients = 0;
+    int ret = clients;
+    if (reset) clients = 0;
     return ret;
 }
 
-// beendet den Server
-bool SSLServer::trenne()
+// stops the server
+bool SSLServer::disconnect()
 {
     if (!s) return 1;
-    if (closesocket(s) < 0) // socket schließen
+    if (closesocket(s) < 0) // close socket
         return 0;
     s = 0;
     return 1;
 }
 
 // constant
-// gibt den Port zurück
+// returns the port
 unsigned short SSLServer::getPort() const
 {
     return htons(addr.sin_port);
 }
 
-// giebt 1 zurück, falls der Server verbunden ist
+// returns 1 if the server is connected
 bool SSLServer::isConnected() const
 {
     return s != 0;
 }
 
-// Inhalt der SSLSKlient Klasse
-// Konstruktor
-SSLSKlient::SSLSKlient(sockaddr_in client, SSL* ssl, SOCKET s)
+// Content of the SSLSClient class
+// Constructor
+SSLSClient::SSLSClient(sockaddr_in client, SSL* ssl, SOCKET s)
     : ReferenceCounter()
 {
     this->s = s;
@@ -627,18 +623,18 @@ SSLSKlient::SSLSKlient(sockaddr_in client, SSL* ssl, SOCKET s)
     upStreamBytes = 0;
 }
 
-// Destruktor
-SSLSKlient::~SSLSKlient()
+// Destructor
+SSLSClient::~SSLSClient()
 {
-    trenne();
+    disconnect();
 #ifdef WIN32
     OPENSSL_thread_stop();
 #endif
 }
 
-// nicht constant
-void SSLSKlient::setEmpfangTimeout(
-    int miliseconds) // Setzt ein timeout fürs empfangen von daten
+// non-constant
+void SSLSClient::setReceiveTimeout(
+    int miliseconds) // Sets a timeout for receiving data
 {
 #ifdef WIN32
     DWORD timeout = miliseconds;
@@ -652,20 +648,20 @@ void SSLSKlient::setEmpfangTimeout(
 #endif
 }
 
-bool SSLSKlient::sende(const char* nachricht, int len) // sendet zum Klient
+bool SSLSClient::send(const char* message, int len) // sends to client
 {
     if (!ssl) return 0;
     int ll = 0;
     while (len > 0)
     {
-        int l = SSL_write(ssl, nachricht + ll, len);
+        int l = SSL_write(ssl, message + ll, len);
         if (l <= 0)
         {
 #ifdef _DEBUG
             Framework::Logging::warning()
                 << "SSL_write: " << l << " Error: " << SSL_get_error(ssl, l);
 #endif
-            return 0; // Fehler
+            return 0; // Error
         }
         len -= l;
         ll += l;
@@ -674,21 +670,20 @@ bool SSLSKlient::sende(const char* nachricht, int len) // sendet zum Klient
     return 1;
 }
 
-bool SSLSKlient::getNachricht(
-    char* nachricht, int len) // empfängt Nachricht von Klient
+bool SSLSClient::getMessage(char* message, int len) // receives message from client
 {
     if (!ssl) return 0;
     int ll = 0;
     while (len > 0)
     {
-        int l = (int)SSL_read(ssl, nachricht + ll, len);
+        int l = (int)SSL_read(ssl, message + ll, len);
         if (l <= 0)
         {
 #ifdef _DEBUG
             Framework::Logging::warning()
                 << "SSL_read: " << l << " Error: " << SSL_get_error(ssl, l);
 #endif
-            return 0; // Fehler
+            return 0; // Error
         }
         len -= l;
         ll += l;
@@ -697,27 +692,27 @@ bool SSLSKlient::getNachricht(
     return 1;
 }
 
-int SSLSKlient::getDownloadBytes(
-    bool reset) // gibt die anzahl von empfangen bytes zurück
+int SSLSClient::getDownloadBytes(
+    bool reset) // returns the number of received bytes
 {
     int ret = downStreamBytes;
     if (reset) downStreamBytes = 0;
     return ret;
 }
 
-int SSLSKlient::getUploadBytes(
-    bool reset) // gibt die anzahl von versendeter bytes zurück
+int SSLSClient::getUploadBytes(
+    bool reset) // returns the number of sent bytes
 {
     int ret = upStreamBytes;
     if (reset) upStreamBytes = 0;
     return ret;
 }
 
-bool SSLSKlient::trenne() // trennt die Verbindung zum Klient
+bool SSLSClient::disconnect() // disconnects from client
 {
     if (!ssl) return 0;
     SSL_free(ssl);
-    if (closesocket(s) < 0) // trennen
+    if (closesocket(s) < 0) // disconnect
         return 0;
     ssl = 0;
     s = 0;
@@ -725,22 +720,22 @@ bool SSLSKlient::trenne() // trennt die Verbindung zum Klient
 }
 
 // constant
-bool SSLSKlient::hatNachricht(
-    int zeit) const // Wartet eine Zeit Lang auf eine Nachricht
+bool SSLSClient::hasMessage(
+    int time) const // Waits for a message for a given time
 {
     fd_set set;
     FD_ZERO(&set);
     FD_SET(SSL_get_rfd(ssl), &set);
-    timeval time = {zeit / 1000, zeit};
+    timeval time = {time / 1000, time};
     return SSL_pending(ssl) > 0 || select(0, &set, 0, 0, &time) == 1;
 }
 
-unsigned short SSLSKlient::getPort() const // gibt den Port zurück
+unsigned short SSLSClient::getPort() const // returns the port
 {
     return htons(clientAddr.sin_port);
 }
 
-const char* SSLSKlient::getIp() const // gibt die Ip des Klients zurück
+const char* SSLSClient::getIp() const // returns the client's IP
 {
     return inet_ntoa(clientAddr.sin_addr);
 }

Network/Server.h

@@ -23,87 +23,87 @@ using namespace Framework;
 
 namespace Network
 {
-    class Server;  // aus dieser Datei
-    class SKlient; // aus dieser Datei
+    class Server;  // from this file
+    class SClient; // from this file
 
     class Server : public virtual ReferenceCounter
     {
     private:
         SOCKET sock;
-        SOCKADDR_IN addresse;
-        int klients;
+        SOCKADDR_IN address;
+        int clients;
 
     public:
-        // Konstruktor
+        // Constructor
         __declspec(dllexport) Server();
-        // Destruktor
+        // Destructor
         __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
+        // non-constant
+        __declspec(dllexport) bool connect(
+            unsigned short port, int queueLength); // Opens the socket
+        __declspec(dllexport) SClient* getClient();      // accepts a client
+        __declspec(dllexport) int getClients(
+            bool reset); // returns the number of clients
+        __declspec(dllexport) bool disconnect(); // stops the server
         // constant
         __declspec(
-            dllexport) unsigned short getPort() const; // gibt den Port zurück
+            dllexport) unsigned short getPort() const; // returns the port
         __declspec(dllexport) bool isConnected()
-            const; // giebt 1 zurück, falls der Server verbunden ist
+            const; // returns 1 if the server is connected
     };
 
-    class SKlient : public EncryptedVerbindung,
+    class SClient : public EncryptedConnection,
                     public virtual ReferenceCounter
     {
     private:
         SOCKET sock;
         sockaddr_in clientAddr;
-        Encryption::Key* sendeKey;
-        Encryption::Key* empfangKey;
+        Encryption::Key* sendKey;
+        Encryption::Key* receiveKey;
         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(
-            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
+        // Constructor
+        __declspec(dllexport) SClient(sockaddr_in client, SOCKET sock);
+        // Destructor
+        __declspec(dllexport) ~SClient();
+        // non-constant
+        __declspec(dllexport) void setReceiveTimeout(
+            int miliseconds); // Sets a timeout for receiving data
+        __declspec(dllexport) void setSendKeyZ(
+            Encryption::Key* key); // Sets the key for sending
+        __declspec(dllexport) void setReceiveKeyZ(
+            Encryption::Key* key); // Sets the key for receiving
+        __declspec(dllexport) void setSendKey(
+            const char* key, int len); // Sets the key for sending
+        __declspec(dllexport) void setReceiveKey(
+            const char* key, int len); // Sets the key for receiving
+        __declspec(dllexport) bool send(
+            const char* message, int len) override; // sends to client
+        __declspec(dllexport) bool getMessage(
+            char* message, int len) override; // receives message from client
+        __declspec(dllexport) bool sendEncrypted(
+            const char* message, int len) override; // sends to server
+        __declspec(dllexport) bool getMessageEncrypted(
+            char* message, int len) override; // receives message
         __declspec(dllexport) int getDownloadBytes(
-            bool reset); // gibt die anzahl von empfangen bytes zurück
+            bool reset); // returns the number of received bytes
         __declspec(dllexport) int getUploadBytes(
-            bool reset); // gibt die anzahl von versendeter bytes zurück
-        __declspec(dllexport) bool trenne(); // trennt die Verbindung zum Klient
+            bool reset); // returns the number of sent bytes
+        __declspec(dllexport) bool disconnect(); // disconnects from client
         // constant
-        __declspec(dllexport) bool hatNachricht(
-            int zeit) const; // Wartet eine Zeit Lang auf eine Nachricht
+        __declspec(dllexport) bool hasMessage(
+            int time) const; // Waits for a message for a given time
         __declspec(
-            dllexport) unsigned short getPort() const; // gibt den Port zurück
+            dllexport) unsigned short getPort() const; // returns the port
         __declspec(dllexport) const
-            char* getIp() const; // gibt die Ip des Klients zurück
+            char* getIp() const; // returns the client's IP
         __declspec(dllexport) bool waitForNextMessage()
-            const; // wartet bis es etwas zu empfangen gibt
+            const; // waits until there is something to receive
     };
 
-    class SSLSKlient;
+    class SSLSClient;
 
     class SSLServer : public virtual ReferenceCounter
     {
@@ -111,40 +111,39 @@ namespace Network
         SOCKET s;
         SOCKADDR_IN addr;
         ssl_ctx_st* ctx;
-        Text* passw;
-        int klients;
+        Text* password;
+        int clients;
 
     public:
-        // Konstruktor
+        // Constructor
         __declspec(dllexport) SSLServer();
-        // Destruktor
+        // Destructor
         __declspec(dllexport) ~SSLServer();
-        // nicht constant
-        // Setzt den Pfad zur Datei, in dem das Certifikat gespeichert ist
+        // non-constant
+        // Sets the path to the file where the certificate is stored
         __declspec(dllexport) bool setCertificateFile(const char* file);
-        // Setzt den Pfad zur Datei, in dem der private Schlüssel gespeichert
-        // ist
+        // Sets the path to the file where the private key is stored
         __declspec(dllexport) bool setPrivateKeyFile(const char* file);
-        // setzt das passwort des private keys (muss vor setPrivateKeyFile
-        // aufgerufen werden)
+        // sets the password of the private key (must be called before
+        // setPrivateKeyFile)
         __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();
+        // Opens the socket
+        __declspec(dllexport) bool connect(
+            unsigned short port, int queueLength);
+        // accepts a client
+        __declspec(dllexport) SSLSClient* getClient();
+        // returns the number of clients
+        __declspec(dllexport) int getClients(bool reset);
+        // stops the server
+        __declspec(dllexport) bool disconnect();
         // constant
-        // gibt den Port zurück
+        // returns the port
         __declspec(dllexport) unsigned short getPort() const;
-        // giebt 1 zurück, falls der Server verbunden ist
+        // returns 1 if the server is connected
         __declspec(dllexport) bool isConnected() const;
     };
 
-    class SSLSKlient : public Verbindung,
+    class SSLSClient : public Connection,
                        public virtual ReferenceCounter
     {
     private:
@@ -155,30 +154,30 @@ namespace Network
         int upStreamBytes;
 
     public:
-        // Konstruktor
+        // Constructor
         __declspec(dllexport)
-            SSLSKlient(sockaddr_in client, ssl_st* 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
+            SSLSClient(sockaddr_in client, ssl_st* ssl, SOCKET s);
+        // Destructor
+        __declspec(dllexport) ~SSLSClient();
+        // non-constant
+        __declspec(dllexport) void setReceiveTimeout(
+            int miliseconds); // Sets a timeout for receiving data
+        __declspec(dllexport) bool send(
+            const char* message, int len) override; // sends to client
+        __declspec(dllexport) bool getMessage(
+            char* message, int len) override; // receives message from client
         __declspec(dllexport) int getDownloadBytes(
-            bool reset); // gibt die anzahl von empfangen bytes zurück
+            bool reset); // returns the number of received bytes
         __declspec(dllexport) int getUploadBytes(
-            bool reset); // gibt die anzahl von versendeter bytes zurück
-        __declspec(dllexport) bool trenne(); // trennt die Verbindung zum Klient
+            bool reset); // returns the number of sent bytes
+        __declspec(dllexport) bool disconnect(); // disconnects from client
         // constant
-        __declspec(dllexport) bool hatNachricht(
-            int zeit) const; // Wartet eine Zeit Lang auf eine Nachricht
+        __declspec(dllexport) bool hasMessage(
+            int time) const; // Waits for a message for a given time
         __declspec(
-            dllexport) unsigned short getPort() const; // gibt den Port zurück
+            dllexport) unsigned short getPort() const; // returns the port
         __declspec(dllexport) const
-            char* getIp() const; // gibt die Ip des Klients zurück
+            char* getIp() const; // returns the client's IP
     };
 } // namespace Network
 

Network/WebSocket.cpp

@@ -1,4 +1,4 @@
-#include "WebSocket.h"
+#include "WebSocket.h"
 
 #include <iostream>
 
@@ -9,7 +9,7 @@ using namespace WebSocket;
 using namespace Framework;
 
 __declspec(dllexport) Frame& Frame::operator+=(
-    const Frame& b) // baut frames zusammen welche zu einer nachricht gehören
+    const Frame& b) // combines frames that belong to a message
 {
     fin = b.fin;
     if (opcode == 0) opcode = b.opcode;
@@ -36,7 +36,7 @@ __declspec(dllexport) WebSocketClient::WebSocketClient(
 {
     queue = new Array<Frame>();
     callback = 0;
-    klient = 0;
+    client = 0;
     this->path = path;
     this->host = host;
     this->port = port;
@@ -130,7 +130,7 @@ __declspec(dllexport) bool WebSocketClient::connect()
         'Z',
         0};
     __int64 numKeyChars = strlen(allowedKeyChars);
-    if (!klient)
+    if (!client)
     {
         Text message = "GET ";
         message += path;
@@ -149,20 +149,20 @@ __declspec(dllexport) bool WebSocketClient::connect()
         message += key;
         delete[] key;
         message += "\r\nSec-WebSocket-Version: 13\r\n\r\n";
-        klient = new Klient();
-        if (!klient->verbinde(port, host))
+        client = new Client();
+        if (!client->connect(port, host))
         {
-            klient = (Klient*)klient->release();
+            client = (Client*)client->release();
             return 0;
         }
-        klient->sende(message, message.getLength());
+        client->send(message, message.getLength());
         Text answer;
         int br = 0;
         do
         {
             char buff[2];
             buff[1] = 0;
-            if (klient->getNachricht(buff, 1))
+            if (client->getMessage(buff, 1))
                 answer += buff;
             else
                 break;
@@ -170,12 +170,12 @@ __declspec(dllexport) bool WebSocketClient::connect()
                 br++;
             else if (buff[0] != '\r')
                 br = 0;
-        } while (br < 2 && klient->hatNachricht(1000));
+        } while (br < 2 && client->hasMessage(1000));
         HTTP::Answer* handshakeResponse = new HTTP::Answer(answer);
         if (handshakeResponse->getStatusCode() != 101)
         {
             handshakeResponse->release();
-            klient = (Klient*)klient->release();
+            client = (Client*)client->release();
             return 0;
         }
         handshakeResponse->release();
@@ -214,15 +214,15 @@ __declspec(dllexport) bool WebSocketClient::send(
 
 __declspec(dllexport) void WebSocketClient::thread()
 {
-    while (klient)
+    while (client)
     {
         c2.lock();
-        if (!klient)
+        if (!client)
         {
             c2.unlock();
             return;
         }
-        if (klient->hatNachricht(100))
+        if (client->hasMessage(100))
         {
             bool ok = 1;
             c2.unlock();
@@ -232,56 +232,56 @@ __declspec(dllexport) void WebSocketClient::thread()
             do
             {
                 c2.lock();
-                if (!klient)
+                if (!client)
                 {
                     c2.unlock();
                     return;
                 }
                 Frame message;
-                ok &= klient->getNachricht((char*)&byte, 1);
+                ok &= client->getMessage((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);
+                ok &= client->getMessage((char*)&byte, 1);
                 message.mask = (byte & 0x80) != 0;
                 message.dataLength = byte & 0x7F;
                 if (message.dataLength == 126)
                 {
-                    ok &= klient->getNachricht((char*)&byte, 1);
+                    ok &= client->getMessage((char*)&byte, 1);
                     message.dataLength = byte << 8;
-                    ok &= klient->getNachricht((char*)&byte, 1);
+                    ok &= client->getMessage((char*)&byte, 1);
                     message.dataLength |= byte;
                 }
                 else if (message.dataLength == 127)
                 {
-                    ok &= klient->getNachricht((char*)&byte, 1);
+                    ok &= client->getMessage((char*)&byte, 1);
                     message.dataLength = (__int64)byte << 56;
-                    ok &= klient->getNachricht((char*)&byte, 1);
+                    ok &= client->getMessage((char*)&byte, 1);
                     message.dataLength |= (__int64)byte << 48;
-                    ok &= klient->getNachricht((char*)&byte, 1);
+                    ok &= client->getMessage((char*)&byte, 1);
                     message.dataLength |= (__int64)byte << 40;
-                    ok &= klient->getNachricht((char*)&byte, 1);
+                    ok &= client->getMessage((char*)&byte, 1);
                     message.dataLength |= (__int64)byte << 32;
-                    ok &= klient->getNachricht((char*)&byte, 1);
+                    ok &= client->getMessage((char*)&byte, 1);
                     message.dataLength |= (__int64)byte << 24;
-                    ok &= klient->getNachricht((char*)&byte, 1);
+                    ok &= client->getMessage((char*)&byte, 1);
                     message.dataLength |= (__int64)byte << 16;
-                    ok &= klient->getNachricht((char*)&byte, 1);
+                    ok &= client->getMessage((char*)&byte, 1);
                     message.dataLength |= (__int64)byte << 8;
-                    ok &= klient->getNachricht((char*)&byte, 1);
+                    ok &= client->getMessage((char*)&byte, 1);
                     message.dataLength |= (__int64)byte;
                 }
                 if (message.mask)
                 {
-                    ok &= klient->getNachricht((char*)&byte, 1);
+                    ok &= client->getMessage((char*)&byte, 1);
                     message.key[0] = byte;
-                    ok &= klient->getNachricht((char*)&byte, 1);
+                    ok &= client->getMessage((char*)&byte, 1);
                     message.key[1] = byte;
-                    ok &= klient->getNachricht((char*)&byte, 1);
+                    ok &= client->getMessage((char*)&byte, 1);
                     message.key[2] = byte;
-                    ok &= klient->getNachricht((char*)&byte, 1);
+                    ok &= client->getMessage((char*)&byte, 1);
                     message.key[3] = byte;
                 }
                 if (!ok) message.dataLength = 1;
@@ -290,7 +290,7 @@ __declspec(dllexport) void WebSocketClient::thread()
                     message.data = new char[(int)message.dataLength];
                 for (int i = 0; i < message.dataLength; i++)
                 {
-                    ok &= klient->getNachricht((char*)&byte, 1);
+                    ok &= client->getMessage((char*)&byte, 1);
                     if (message.mask)
                         message.data[i] = byte ^ message.key[i % 4];
                     else
@@ -331,8 +331,8 @@ __declspec(dllexport) void WebSocketClient::thread()
                 {
                     delete[] m.data;
                     c2.lock();
-                    klient->trenne();
-                    klient = (Klient*)klient->release();
+                    client->disconnect();
+                    client = (Client*)client->release();
                     c2.unlock();
                     return;
                 }
@@ -367,12 +367,12 @@ __declspec(dllexport) void WebSocketClient::thread()
                 byte |= (f.rsv3 ? 1 : 0) << 4;
                 byte |= f.opcode & 0xF;
                 c2.lock();
-                if (!klient)
+                if (!client)
                 {
                     c2.unlock();
                     return;
                 }
-                klient->sende((char*)&byte, 1);
+                client->send((char*)&byte, 1);
                 byte = (f.mask ? 1 : 0) << 7;
                 if (f.dataLength < 126)
                     byte |= (unsigned char)f.dataLength & 0x7F;
@@ -380,46 +380,46 @@ __declspec(dllexport) void WebSocketClient::thread()
                     byte |= 126;
                 else
                     byte |= 127;
-                klient->sende((char*)&byte, 1);
+                client->send((char*)&byte, 1);
                 if (f.dataLength >= 126)
                 {
                     if (f.dataLength <= 32767)
                     {
                         byte = (unsigned char)(f.dataLength >> 8);
-                        klient->sende((char*)&byte, 1);
+                        client->send((char*)&byte, 1);
                         byte = (unsigned char)f.dataLength & 0xFF;
-                        klient->sende((char*)&byte, 1);
+                        client->send((char*)&byte, 1);
                     }
                     else
                     {
                         byte = (unsigned char)(f.dataLength >> 56);
-                        klient->sende((char*)&byte, 1);
+                        client->send((char*)&byte, 1);
                         byte = (unsigned char)(f.dataLength >> 48);
-                        klient->sende((char*)&byte, 1);
+                        client->send((char*)&byte, 1);
                         byte = (unsigned char)(f.dataLength >> 40);
-                        klient->sende((char*)&byte, 1);
+                        client->send((char*)&byte, 1);
                         byte = (unsigned char)(f.dataLength >> 32);
-                        klient->sende((char*)&byte, 1);
+                        client->send((char*)&byte, 1);
                         byte = (unsigned char)(f.dataLength >> 24);
-                        klient->sende((char*)&byte, 1);
+                        client->send((char*)&byte, 1);
                         byte = (unsigned char)(f.dataLength >> 16);
-                        klient->sende((char*)&byte, 1);
+                        client->send((char*)&byte, 1);
                         byte = (unsigned char)(f.dataLength >> 8);
-                        klient->sende((char*)&byte, 1);
+                        client->send((char*)&byte, 1);
                         byte = (unsigned char)f.dataLength & 0xFF;
-                        klient->sende((char*)&byte, 1);
+                        client->send((char*)&byte, 1);
                     }
                 }
                 if (f.mask)
                 {
                     byte = (unsigned char)f.key[0];
-                    klient->sende((char*)&byte, 1);
+                    client->send((char*)&byte, 1);
                     byte = (unsigned char)f.key[1];
-                    klient->sende((char*)&byte, 1);
+                    client->send((char*)&byte, 1);
                     byte = (unsigned char)f.key[2];
-                    klient->sende((char*)&byte, 1);
+                    client->send((char*)&byte, 1);
                     byte = (unsigned char)f.key[3];
-                    klient->sende((char*)&byte, 1);
+                    client->send((char*)&byte, 1);
                 }
                 if (f.dataLength)
                 {
@@ -429,7 +429,7 @@ __declspec(dllexport) void WebSocketClient::thread()
                             byte = (unsigned char)f.data[i] ^ f.key[i % 4];
                         else
                             byte = (unsigned char)f.data[i];
-                        klient->sende((char*)&byte, 1);
+                        client->send((char*)&byte, 1);
                     }
                 }
                 c2.unlock();
@@ -442,8 +442,8 @@ __declspec(dllexport) void WebSocketClient::thread()
                     {
                         c.unlock();
                         c2.lock();
-                        klient->trenne();
-                        klient = (Klient*)klient->release();
+                        client->disconnect();
+                        client = (Client*)client->release();
                         c2.unlock();
                         return;
                     }
@@ -460,15 +460,15 @@ __declspec(dllexport) void WebSocketClient::thread()
 
 __declspec(dllexport) void WebSocketClient::disconnect()
 {
-    if (!klient) return;
+    if (!client) return;
     c2.lock();
-    klient->trenne();
-    klient = (Klient*)klient->release();
+    client->disconnect();
+    client = (Client*)client->release();
     c2.unlock();
     warteAufThread(1000);
 }
 
 __declspec(dllexport) bool WebSocketClient::isConnected() const
 {
-    return klient != 0;
+    return client != 0;
 }

Network/WebSocket.h

@@ -1,11 +1,11 @@
-#pragma once
+#pragma once
 
 #include <Critical.h>
 #include <functional>
 #include <Random.h>
 #include <Thread.h>
 
-#include "Klient.h"
+#include "Client.h"
 
 namespace Network
 {
@@ -13,13 +13,13 @@ namespace Network
     {
         struct Frame
         {
-            bool fin, rsv1, rsv2, rsv3; // bit 0 bis 3
-            char opcode;                // bit 4 bis 7
+            bool fin, rsv1, rsv2, rsv3; // bit 0 to 3
+            char opcode;                // bit 4 to 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
+            __int64 dataLength;         // bit 9 to 15 or to 31 or to 79
+            unsigned char key[4]; // if mask = 1 then the next 32 bits
+            char* data;           // the data
+            // combines frames that belong to a message
             __declspec(dllexport) Frame& operator+=(const Frame& b);
         };
 
@@ -35,7 +35,7 @@ namespace Network
             std::function<void(
                 WebSocketClient*, __int64 size, const char* data, DataType typ)>
                 callback;
-            Klient* klient;
+            Client* client;
             Framework::Text path;
             Framework::Text host;
             Frame* lastPingFrame;
@@ -47,34 +47,32 @@ namespace Network
             bool nextClose;
 
         public:
-            // Erstellt ein neues Websocket
-            //  path: Der Pfad zur Resource
-            //  host: Die Adresse des Servers
-            //  port: Der Port des Servers
+            // Creates a new WebSocket
+            //  path: The path to the resource
+            //  host: The address of the server
+            //  port: The port of the server
             __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
+            // Sets the function to be called for processing server messages
             __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
+            // Performs the WebSocket handshake if not yet connected
             __declspec(dllexport) bool connect();
-            // Sendet eine Nachricht an den Server
-            //  size: Die länge der Nachricht
-            //  data: Die Daten
-            //  typ: Den Typ der Nachricht
+            // Sends a message to the server
+            //  size: The length of the message
+            //  data: The data
+            //  typ: The type of the message
             __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
+            // This function processes server messages. It should not be called manually as it is started automatically
             __declspec(dllexport) void thread() override;
-            // bricht die verbindung ab
+            // aborts the connection
             __declspec(dllexport) void disconnect();
-            // Gibt 1 zurück, wenn eine Verbindung zum Server besteht, 0 sonnst
+            // Returns 1 if a connection to the server exists, 0 otherwise
             __declspec(dllexport) bool isConnected() const;
         };
     } // namespace WebSocket