Merge pull request #378 from Niklas04/patch-1

Update WebSocketsClient.cpp
2019-05-30 16:48:05 +02:00 · 2018-10-09 21:28:02 +02:00 · 2018-05-19 19:26:12 +02:00 · 2016-12-27 14:16:12 +01:00
17 changed files with 431 additions and 882 deletions
--- a/.travis.yml
+++ b/.travis.yml
@ -0,0 +1,39 @@
+sudo: false
+language: bash
+os:
+  - linux
+env:
+  matrix:
+    - CPU="esp8266" BOARD="esp8266com:esp8266:generic:CpuFrequency=80" IDE_VERSION=1.6.5
+    - CPU="esp8266" BOARD="esp8266com:esp8266:generic:CpuFrequency=80,FlashSize=1M0,FlashMode=qio,FlashFreq=80" IDE_VERSION=1.8.5
+    - CPU="esp8266" BOARD="esp8266com:esp8266:generic:CpuFrequency=80,Debug=Serial1" IDE_VERSION=1.6.5
+    - CPU="avr" BOARD="arduino:avr:mega:cpu=atmega2560" IDE_VERSION=1.6.5
+
+script:
+  - /sbin/start-stop-daemon --start --quiet --pidfile /tmp/custom_xvfb_1.pid --make-pidfile --background --exec /usr/bin/Xvfb -- :1 -ac -screen 0 1280x1024x16
+  - sleep 3
+  - export DISPLAY=:1.0
+  - wget http://downloads.arduino.cc/arduino-$IDE_VERSION-linux64.tar.xz
+  - tar xf arduino-$IDE_VERSION-linux64.tar.xz
+  - mv arduino-$IDE_VERSION $HOME/arduino_ide
+  - export PATH="$HOME/arduino_ide:$PATH"
+  - which arduino
+  - mkdir -p $HOME/Arduino/libraries
+  - cp -r $TRAVIS_BUILD_DIR $HOME/Arduino/libraries/arduinoWebSockets
+  - source $TRAVIS_BUILD_DIR/travis/common.sh
+  - get_core $CPU
+  - cd $TRAVIS_BUILD_DIR
+  - arduino --board $BOARD --save-prefs
+  - arduino --get-pref sketchbook.path
+  - build_sketches arduino $HOME/Arduino/libraries/arduinoWebSockets/examples/$CPU $CPU
+
+notifications:
+  email:
+    on_success: change
+    on_failure: change
+  webhooks:
+    urls:
+      - https://webhooks.gitter.im/e/1aa78fbe15080b0c2e37
+    on_success: change  # options: [always|never|change] default: always
+    on_failure: always  # options: [always|never|change] default: always
+    on_start: false     # default: false
--- a/README.md
+++ b/README.md
@ -21,32 +21,15 @@ a WebSocket Server and Client for Arduino based on RFC6455.

 ##### Supported Hardware #####
 - ESP8266 [Arduino for ESP8266](https://github.com/Links2004/Arduino)
- - ESP31B
- - ATmega328 with Ethernet Shield (ATmega branch) 
- - ATmega328 with enc28j60 (ATmega branch) 
- - ATmega2560 with Ethernet Shield (ATmega branch) 
- - ATmega2560 with enc28j60 (ATmega branch) 
- 
-###### Note: ######
-
-  version 2.0 and up is not compatible with AVR/ATmega, check ATmega branch.
-  
-  Arduino for AVR not supports std namespace of c++.
+ - ATmega328 with Ethernet Shield (alpha)
+ - ATmega328 with enc28j60 (alpha)
+ - ATmega2560 with Ethernet Shield (alpha)
+ - ATmega2560 with enc28j60 (alpha)
 
 ### wss / SSL ###
 supported for:
 - wss client on the ESP8266
 
-### ESP Async TCP ###
-
-This libary can run in Async TCP mode on the ESP.
-
-The mode can be aktivated in the ```WebSockets.h``` (see WEBSOCKETS_NETWORK_TYPE define).
-
-[ESPAsyncTCP](https://github.com/me-no-dev/ESPAsyncTCP) libary is required.
-
-Note: in this mode wss / SSL is not possible.
-
 ### Issues ###
 Submit issues to: https://github.com/Links2004/arduinoWebSockets/issues

--- a/examples/avr/WebSocketClientAVR/WebSocketClientAVR.ino
+++ b/examples/avr/WebSocketClientAVR/WebSocketClientAVR.ino
--- a/examples/esp8266/WebSocketClient/WebSocketClient.ino
+++ b/examples/esp8266/WebSocketClient/WebSocketClient.ino
@ -77,7 +77,6 @@ void setup() {
    }

    webSocket.begin("192.168.0.123", 81);
-    //webSocket.setAuthorization("user", "Password"); // HTTP Basic Authorization
    webSocket.onEvent(webSocketEvent);

 }
--- a/examples/esp8266/WebSocketClientSSL/WebSocketClientSSL.ino
+++ b/examples/esp8266/WebSocketClientSSL/WebSocketClientSSL.ino
--- a/examples/esp8266/WebSocketServer/WebSocketServer.ino
+++ b/examples/esp8266/WebSocketServer/WebSocketServer.ino
--- a/examples/esp8266/WebSocketServer_LEDcontrol/WebSocketServer_LEDcontrol.ino
+++ b/examples/esp8266/WebSocketServer_LEDcontrol/WebSocketServer_LEDcontrol.ino
--- a/library.properties
+++ b/library.properties
@ -1,9 +1,9 @@
 name=WebSockets
-version=2.0
+version=1.3
 author=Markus Sattler
 maintainer=Markus Sattler 
 sentence=WebSockets for Arduino (Server + Client)
-paragraph=use 2.0 for ESP and 1.3 for AVR
+paragraph=
 category=Communication
 url=https://github.com/Links2004/arduinoWebSockets
 architectures=*
--- a/src/WebSockets.cpp
+++ b/src/WebSockets.cpp
@ -30,9 +30,9 @@

 extern "C" {
 #ifdef CORE_HAS_LIBB64
-#include <libb64/cencode.h>
+    #include <libb64/cencode.h>
 #else
-#include "libb64/cencode_inc.h"
+    #include "libb64/cencode_inc.h"
 #endif
 }

@ -46,6 +46,8 @@ extern "C" {

 #endif

+#define WEBSOCKETS_MAX_HEADER_SIZE  (14)
+
 /**
 *
 * @param client WSclient_t *  ptr to the client struct
@ -77,18 +79,17 @@ void WebSockets::clientDisconnect(WSclient_t * client, uint16_t code, char * rea
 * @param mask bool             add dummy mask to the frame (needed for web browser)
 * @param fin bool              can be used to send data in more then one frame (set fin on the last frame)
 * @param headerToPayload bool  set true if the payload has reserved 14 Byte at the beginning to dynamically add the Header (payload neet to be in RAM!)
- * @return true if ok
 */
-bool WebSockets::sendFrame(WSclient_t * client, WSopcode_t opcode, uint8_t * payload, size_t length, bool mask, bool fin, bool headerToPayload) {
+void WebSockets::sendFrame(WSclient_t * client, WSopcode_t opcode, uint8_t * payload, size_t length, bool mask, bool fin, bool headerToPayload) {

    if(client->tcp && !client->tcp->connected()) {
        DEBUG_WEBSOCKETS("[WS][%d][sendFrame] not Connected!?\n", client->num);
-        return false;
+        return;
    }

    if(client->status != WSC_CONNECTED) {
        DEBUG_WEBSOCKETS("[WS][%d][sendFrame] not in WSC_CONNECTED state!?\n", client->num);
-        return false;
+        return;
    }

    DEBUG_WEBSOCKETS("[WS][%d][sendFrame] ------- send massage frame -------\n", client->num);
@ -105,7 +106,6 @@ bool WebSockets::sendFrame(WSclient_t * client, WSopcode_t opcode, uint8_t * pay
    uint8_t * headerPtr;
    uint8_t * payloadPtr = payload;
    bool useInternBuffer = false;
-    bool ret = true;

    // calculate header Size
    if(length < 126) {
@ -120,6 +120,7 @@ bool WebSockets::sendFrame(WSclient_t * client, WSopcode_t opcode, uint8_t * pay
        headerSize += 4;
    }

+
 #ifdef WEBSOCKETS_USE_BIG_MEM
    // only for ESP since AVR has less HEAP
    // try to send data in one TCP package (only if some free Heap is there)
@ -160,35 +161,22 @@ bool WebSockets::sendFrame(WSclient_t * client, WSopcode_t opcode, uint8_t * pay
    }

    if(length < 126) {
-        *headerPtr |= length;
-        headerPtr++;
+        *headerPtr |= length;                   headerPtr++;
    } else if(length < 0xFFFF) {
-        *headerPtr |= 126;
-        headerPtr++;
-        *headerPtr = ((length >> 8) & 0xFF);
-        headerPtr++;
-        *headerPtr = (length & 0xFF);
-        headerPtr++;
+        *headerPtr |= 126;                      headerPtr++;
+        *headerPtr = ((length >> 8) & 0xFF);    headerPtr++;
+        *headerPtr = (length & 0xFF);           headerPtr++;
    } else {
        // Normally we never get here (to less memory)
-        *headerPtr |= 127;
-        headerPtr++;
-        *headerPtr = 0x00;
-        headerPtr++;
-        *headerPtr = 0x00;
-        headerPtr++;
-        *headerPtr = 0x00;
-        headerPtr++;
-        *headerPtr = 0x00;
-        headerPtr++;
-        *headerPtr = ((length >> 24) & 0xFF);
-        headerPtr++;
-        *headerPtr = ((length >> 16) & 0xFF);
-        headerPtr++;
-        *headerPtr = ((length >> 8) & 0xFF);
-        headerPtr++;
-        *headerPtr = (length & 0xFF);
-        headerPtr++;
+        *headerPtr |= 127;                      headerPtr++;
+        *headerPtr = 0x00;                      headerPtr++;
+        *headerPtr = 0x00;                      headerPtr++;
+        *headerPtr = 0x00;                      headerPtr++;
+        *headerPtr = 0x00;                      headerPtr++;
+        *headerPtr = ((length >> 24) & 0xFF);   headerPtr++;
+        *headerPtr = ((length >> 16) & 0xFF);   headerPtr++;
+        *headerPtr = ((length >> 8) & 0xFF);    headerPtr++;
+        *headerPtr = (length & 0xFF);           headerPtr++;
    }

    if(mask) {
@ -197,8 +185,7 @@ bool WebSockets::sendFrame(WSclient_t * client, WSopcode_t opcode, uint8_t * pay
            // by this fact its possible the do the masking
            for(uint8_t x = 0; x < sizeof(maskKey); x++) {
                maskKey[x] = random(0xFF);
-                *headerPtr = maskKey[x];
-                headerPtr++;
+                *headerPtr = maskKey[x];       headerPtr++;
            }

            uint8_t * dataMaskPtr;
@ -214,14 +201,10 @@ bool WebSockets::sendFrame(WSclient_t * client, WSopcode_t opcode, uint8_t * pay
            }

        } else {
-            *headerPtr = maskKey[0];
-            headerPtr++;
-            *headerPtr = maskKey[1];
-            headerPtr++;
-            *headerPtr = maskKey[2];
-            headerPtr++;
-            *headerPtr = maskKey[3];
-            headerPtr++;
+            *headerPtr = maskKey[0];          headerPtr++;
+            *headerPtr = maskKey[1];          headerPtr++;
+            *headerPtr = maskKey[2];          headerPtr++;
+            *headerPtr = maskKey[3];          headerPtr++;
        }
    }

@ -233,20 +216,14 @@ bool WebSockets::sendFrame(WSclient_t * client, WSopcode_t opcode, uint8_t * pay
        // header has be added to payload
        // payload is forced to reserved 14 Byte but we may not need all based on the length and mask settings
        // offset in payload is calculatetd 14 - headerSize
-        if(client->tcp->write(&payloadPtr[(WEBSOCKETS_MAX_HEADER_SIZE - headerSize)], (length + headerSize)) != (length + headerSize)) {
-            ret = false;
-        }
+        client->tcp->write(&payloadPtr[(WEBSOCKETS_MAX_HEADER_SIZE - headerSize)], (length + headerSize));
    } else {
        // send header
-        if(client->tcp->write(&buffer[0], headerSize) != headerSize) {
-            ret = false;
-        }
+        client->tcp->write(&buffer[0], headerSize);

        if(payloadPtr && length > 0) {
            // send payload
-            if(client->tcp->write(&payloadPtr[0], length) != length) {
-                ret = false;
-            }
+            client->tcp->write(&payloadPtr[0], length);
        }
    }

@ -258,21 +235,6 @@ bool WebSockets::sendFrame(WSclient_t * client, WSopcode_t opcode, uint8_t * pay
    }
 #endif

-    return ret;
-}
-
-/**
- * callen when HTTP header is done
- * @param client WSclient_t *  ptr to the client struct
- */
-void WebSockets::headerDone(WSclient_t * client) {
-    client->status = WSC_CONNECTED;
-    client->cWsRXsize = 0;
-    DEBUG_WEBSOCKETS("[WS][%d][headerDone] Header Handling Done (%uus).\n", client->num);
-#if (WEBSOCKETS_NETWORK_TYPE == NETWORK_ESP8266_ASYNC)
-    client->cHttpLine = "";
-    handleWebsocket(client);
-#endif
 }

 /**
@ -280,201 +242,149 @@ void WebSockets::headerDone(WSclient_t * client) {
 * @param client WSclient_t *  ptr to the client struct
 */
 void WebSockets::handleWebsocket(WSclient_t * client) {
-    if(client->cWsRXsize == 0) {
-        handleWebsocketCb(client);
-    }
-}

-/**
- * wait for
- * @param client
- * @param size
- */
-bool WebSockets::handleWebsocketWaitFor(WSclient_t * client, size_t size) {
-    if(!client->tcp || !client->tcp->connected()) {
-        return false;
-    }
+    uint8_t buffer[8] = { 0 };

-    if(size > WEBSOCKETS_MAX_HEADER_SIZE) {
-        DEBUG_WEBSOCKETS("[WS][%d][handleWebsocketWaitFor] size: %d to big!\n", client->num, size);
-        return false;
-    }
+    bool fin;
+    bool rsv1;
+    bool rsv2;
+    bool rsv3;
+    WSopcode_t opCode;
+    bool mask;
+    size_t payloadLen;

-    if(client->cWsRXsize >= size) {
-        return true;
-    }
+    uint8_t maskKey[4];

-    DEBUG_WEBSOCKETS("[WS][%d][handleWebsocketWaitFor] size: %d cWsRXsize: %d\n", client->num, size, client->cWsRXsize);
-    readCb(client, &client->cWsHeader[client->cWsRXsize], (size - client->cWsRXsize), std::bind([](WebSockets * server, size_t size, WSclient_t * client, bool ok) {
-        DEBUG_WEBSOCKETS("[WS][%d][handleWebsocketWaitFor][readCb] size: %d ok: %d\n", client->num, size, ok);
-        if(ok) {
-            client->cWsRXsize = size;
-            server->handleWebsocketCb(client);
-        } else {
-            DEBUG_WEBSOCKETS("[WS][%d][readCb] failed.\n", client->num);
-            client->cWsRXsize = 0;
-            // timeout or error
-            server->clientDisconnect(client, 1002);
-        }
-    }, this, size, std::placeholders::_1, std::placeholders::_2));
-    return false;
-}
-
-void WebSockets::handleWebsocketCb(WSclient_t * client) {
-
-    if(!client->tcp || !client->tcp->connected()) {
-        return;
-    }
-
-    uint8_t * buffer = client->cWsHeader;
-
-    WSMessageHeader_t * header = &client->cWsHeaderDecode;
    uint8_t * payload = NULL;

-    uint8_t headerLen = 2;
+    DEBUG_WEBSOCKETS("[WS][%d][handleWebsocket] ------- read massage frame -------\n", client->num);

-    if(!handleWebsocketWaitFor(client, headerLen)) {
+    if(!readWait(client, buffer, 2)) {
+        //timeout
+        clientDisconnect(client, 1002);
        return;
    }

    // split first 2 bytes in the data
-    header->fin = ((*buffer >> 7) & 0x01);
-    header->rsv1 = ((*buffer >> 6) & 0x01);
-    header->rsv2 = ((*buffer >> 5) & 0x01);
-    header->rsv3 = ((*buffer >> 4) & 0x01);
-    header->opCode = (WSopcode_t) (*buffer & 0x0F);
-    buffer++;
+    fin = ((buffer[0] >> 7) & 0x01);
+    rsv1 = ((buffer[0] >> 6) & 0x01);
+    rsv2 = ((buffer[0] >> 5) & 0x01);
+    rsv3 = ((buffer[0] >> 4) & 0x01);
+    opCode = (WSopcode_t) (buffer[0] & 0x0F);

-    header->mask = ((*buffer >> 7) & 0x01);
-    header->payloadLen = (WSopcode_t) (*buffer & 0x7F);
-    buffer++;
+    mask = ((buffer[1] >> 7) & 0x01);
+    payloadLen = (WSopcode_t) (buffer[1] & 0x7F);

-    if(header->payloadLen == 126) {
-        headerLen += 2;
-        if(!handleWebsocketWaitFor(client, headerLen)) {
+    if(payloadLen == 126) {
+        if(!readWait(client, buffer, 2)) {
+            //timeout
+            clientDisconnect(client, 1002);
            return;
        }
-        header->payloadLen = buffer[0] << 8 | buffer[1];
-        buffer += 2;
-    } else if(header->payloadLen == 127) {
-        headerLen += 8;
+        payloadLen = buffer[0] << 8 | buffer[1];
+    } else if(payloadLen == 127) {
        // read 64bit integer as length
-        if(!handleWebsocketWaitFor(client, headerLen)) {
+        if(!readWait(client, buffer, 8)) {
+            //timeout
+            clientDisconnect(client, 1002);
            return;
        }

        if(buffer[0] != 0 || buffer[1] != 0 || buffer[2] != 0 || buffer[3] != 0) {
            // really to big!
-            header->payloadLen = 0xFFFFFFFF;
+            payloadLen = 0xFFFFFFFF;
        } else {
-            header->payloadLen = buffer[4] << 24 | buffer[5] << 16 | buffer[6] << 8 | buffer[7];
+            payloadLen = buffer[4] << 24 | buffer[5] << 16 | buffer[6] << 8 | buffer[7];
        }
-        buffer += 8;
    }

-    DEBUG_WEBSOCKETS("[WS][%d][handleWebsocket] ------- read massage frame -------\n", client->num);
-    DEBUG_WEBSOCKETS("[WS][%d][handleWebsocket] fin: %u rsv1: %u rsv2: %u rsv3 %u  opCode: %u\n", client->num, header->fin, header->rsv1, header->rsv2, header->rsv3, header->opCode);
-    DEBUG_WEBSOCKETS("[WS][%d][handleWebsocket] mask: %u payloadLen: %u\n", client->num, header->mask, header->payloadLen);
+    DEBUG_WEBSOCKETS("[WS][%d][handleWebsocket] fin: %u rsv1: %u rsv2: %u rsv3 %u  opCode: %u\n", client->num, fin, rsv1, rsv2, rsv3, opCode);
+    DEBUG_WEBSOCKETS("[WS][%d][handleWebsocket] mask: %u payloadLen: %u\n", client->num, mask, payloadLen);

-    if(header->payloadLen > WEBSOCKETS_MAX_DATA_SIZE) {
-        DEBUG_WEBSOCKETS("[WS][%d][handleWebsocket] payload to big! (%u)\n", client->num, header->payloadLen);
+    if(payloadLen > WEBSOCKETS_MAX_DATA_SIZE) {
+        DEBUG_WEBSOCKETS("[WS][%d][handleWebsocket] payload to big! (%u)\n", client->num, payloadLen);
        clientDisconnect(client, 1009);
        return;
    }

-    if(header->mask) {
-        headerLen += 4;
-        if(!handleWebsocketWaitFor(client, headerLen)) {
+    if(mask) {
+        if(!readWait(client, maskKey, 4)) {
+            //timeout
+            clientDisconnect(client, 1002);
            return;
        }
-        header->maskKey = buffer;
-        buffer += 4;
    }

-    if(header->payloadLen > 0) {
+    if(payloadLen > 0) {
        // if text data we need one more
-        payload = (uint8_t *) malloc(header->payloadLen + 1);
+        payload = (uint8_t *) malloc(payloadLen + 1);

        if(!payload) {
-            DEBUG_WEBSOCKETS("[WS][%d][handleWebsocket] to less memory to handle payload %d!\n", client->num, header->payloadLen);
+            DEBUG_WEBSOCKETS("[WS][%d][handleWebsocket] to less memory to handle payload %d!\n", client->num, payloadLen);
            clientDisconnect(client, 1011);
            return;
        }
-        readCb(client, payload, header->payloadLen, std::bind(&WebSockets::handleWebsocketPayloadCb, this, std::placeholders::_1, std::placeholders::_2, payload));
-    } else {
-        handleWebsocketPayloadCb(client, true, NULL);
-    }
-}

-void WebSockets::handleWebsocketPayloadCb(WSclient_t * client, bool ok, uint8_t * payload) {
-
-    WSMessageHeader_t * header = &client->cWsHeaderDecode;
-    if(ok) {
-        if(header->payloadLen > 0) {
-            payload[header->payloadLen] = 0x00;
-
-            if(header->mask) {
-                //decode XOR
-                for(size_t i = 0; i < header->payloadLen; i++) {
-                    payload[i] = (payload[i] ^ header->maskKey[i % 4]);
-                }
-            }
+        if(!readWait(client, payload, payloadLen)) {
+            DEBUG_WEBSOCKETS("[WS][%d][handleWebsocket] missing data!\n", client->num);
+            free(payload);
+            clientDisconnect(client, 1002);
+            return;
        }

-        switch(header->opCode) {
-            case WSop_text:
-                DEBUG_WEBSOCKETS("[WS][%d][handleWebsocket] text: %s\n", client->num, payload);
-                // no break here!
-            case WSop_binary:
-                messageRecived(client, header->opCode, payload, header->payloadLen);
-                break;
-            case WSop_ping:
-                // send pong back
-                sendFrame(client, WSop_pong, payload, header->payloadLen);
-                break;
-            case WSop_pong:
-                DEBUG_WEBSOCKETS("[WS][%d][handleWebsocket] get pong  (%s)\n", client->num, payload);
-                break;
-            case WSop_close: {
+        payload[payloadLen] = 0x00;
+
+        if(mask) {
+            //decode XOR
+            for(size_t i = 0; i < payloadLen; i++) {
+                payload[i] = (payload[i] ^ maskKey[i % 4]);
+            }
+        }
+    }
+
+    switch(opCode) {
+        case WSop_text:
+            DEBUG_WEBSOCKETS("[WS][%d][handleWebsocket] text: %s\n", client->num, payload);
+            // no break here!
+        case WSop_binary:
+            messageRecived(client, opCode, payload, payloadLen);
+            break;
+        case WSop_ping:
+            // send pong back
+            sendFrame(client, WSop_pong, payload, payloadLen);
+            break;
+        case WSop_pong:
+            DEBUG_WEBSOCKETS("[WS][%d][handleWebsocket] get pong  (%s)\n", client->num, payload);
+            break;
+        case WSop_close:
+            {
                uint16_t reasonCode = 1000;
-                if(header->payloadLen >= 2) {
+                if(payloadLen >= 2) {
                    reasonCode = payload[0] << 8 | payload[1];
                }

                DEBUG_WEBSOCKETS("[WS][%d][handleWebsocket] get ask for close. Code: %d", client->num, reasonCode);
-                if(header->payloadLen > 2) {
-                    DEBUG_WEBSOCKETS(" (%s)\n", (payload + 2));
+                if(payloadLen > 2) {
+                    DEBUG_WEBSOCKETS(" (%s)\n", (payload+2));
                } else {
                    DEBUG_WEBSOCKETS("\n");
                }
                clientDisconnect(client, 1000);
            }
-                break;
-            case WSop_continuation:
-                // continuation is not supported
-                clientDisconnect(client, 1003);
-                break;
-            default:
-                clientDisconnect(client, 1002);
-                break;
-        }
-
-        if(payload) {
-            free(payload);
-        }
-
-        // reset input
-        client->cWsRXsize = 0;
-#if (WEBSOCKETS_NETWORK_TYPE == NETWORK_ESP8266_ASYNC)
-        //register callback for next message
-        handleWebsocketWaitFor(client, 2);
-#endif
-
-    } else {
-        DEBUG_WEBSOCKETS("[WS][%d][handleWebsocket] missing data!\n", client->num);
-        free(payload);
-        clientDisconnect(client, 1002);
+            break;
+        case WSop_continuation:
+            // continuation is not supported
+            clientDisconnect(client, 1003);
+            break;
+        default:
+            clientDisconnect(client, 1002);
+            break;
    }
+
+    if(payload) {
+        free(payload);
+    }
+
 }

 /**
@ -482,7 +392,7 @@ void WebSockets::handleWebsocketPayloadCb(WSclient_t * client, bool ok, uint8_t
 * @param clientKey String
 * @return String Accept Key
 */
-String WebSockets::acceptKey(String & clientKey) {
+String WebSockets::acceptKey(String clientKey) {
    uint8_t sha1HashBin[20] = { 0 };
 #ifdef ESP8266
    sha1(clientKey + "258EAFA5-E914-47DA-95CA-C5AB0DC85B11", &sha1HashBin[0]);
@ -507,7 +417,7 @@ String WebSockets::acceptKey(String & clientKey) {
 * @return base64 encoded String
 */
 String WebSockets::base64_encode(uint8_t * data, size_t length) {
-    size_t size = ((length * 1.6f) + 1);
+    size_t size = ((length*1.6f)+1);
    char * buffer = (char *) malloc(size);
    if(buffer) {
        base64_encodestate _state;
@ -529,49 +439,28 @@ String WebSockets::base64_encode(uint8_t * data, size_t length) {
 * @param n size_t byte count
 * @return true if ok
 */
-bool WebSockets::readCb(WSclient_t * client, uint8_t * out, size_t n, WSreadWaitCb cb) {
-#if (WEBSOCKETS_NETWORK_TYPE == NETWORK_ESP8266_ASYNC)
-    if(!client->tcp || !client->tcp->connected()) {
-        return false;
-    }
-
-    client->tcp->readBytes(out, n, std::bind([](WSclient_t * client, bool ok, WSreadWaitCb cb) {
-        if(cb) {
-            cb(client, ok);
-        }
-    }, client, std::placeholders::_1, cb));
-
-#else
+bool WebSockets::readWait(WSclient_t * client, uint8_t *out, size_t n) {
    unsigned long t = millis();
    size_t len;
-    DEBUG_WEBSOCKETS("[readCb] n: %d t: %d\n", n, t);
+
    while(n > 0) {
-        if(client->tcp == NULL) {
-            DEBUG_WEBSOCKETS("[readCb] tcp is null!\n");
-            if(cb) {
-                cb(client, false);
-            }
+        if(!client->tcp) {
+            DEBUG_WEBSOCKETS("[readWait] tcp is null!\n");
            return false;
        }

        if(!client->tcp->connected()) {
-            DEBUG_WEBSOCKETS("[readCb] not connected!\n");
-            if(cb) {
-                cb(client, false);
-            }
+            DEBUG_WEBSOCKETS("[readWait] not connected!\n");
            return false;
        }

        if((millis() - t) > WEBSOCKETS_TCP_TIMEOUT) {
-            DEBUG_WEBSOCKETS("[readCb] receive TIMEOUT! %d\n", (millis() - t));
-            if(cb) {
-                cb(client, false);
-            }
+            DEBUG_WEBSOCKETS("[readWait] receive TIMEOUT!\n");
            return false;
        }

        if(!client->tcp->available()) {
-#if (WEBSOCKETS_NETWORK_TYPE == NETWORK_ESP8266)
+#ifdef ESP8266
            delay(0);
 #endif
            continue;
@ -586,14 +475,9 @@ bool WebSockets::readCb(WSclient_t * client, uint8_t * out, size_t n, WSreadWait
        } else {
            //DEBUG_WEBSOCKETS("Receive %d left %d!\n", len, n);
        }
-#if (WEBSOCKETS_NETWORK_TYPE == NETWORK_ESP8266)
+#ifdef ESP8266
        delay(0);
 #endif
    }
-    if(cb) {
-        cb(client, true);
-    }
-#endif
    return true;
 }
-
--- a/src/WebSockets.h
+++ b/src/WebSockets.h
@ -27,7 +27,7 @@

 #include <Arduino.h>

-//#define DEBUG_WEBSOCKETS(...) os_printf( __VA_ARGS__ )
+//#define DEBUG_WEBSOCKETS(...) Serial1.printf( __VA_ARGS__ )

 #ifndef DEBUG_WEBSOCKETS
 #define DEBUG_WEBSOCKETS(...)
@ -42,55 +42,28 @@
 #define WEBSOCKETS_MAX_DATA_SIZE  (1024)
 #endif

-#define WEBSOCKETS_TCP_TIMEOUT    (2000)
+#define WEBSOCKETS_TCP_TIMEOUT    (1500)

-#define NETWORK_ESP8266_ASYNC   (0)
-#define NETWORK_ESP8266         (1)
-#define NETWORK_W5100           (2)
-#define NETWORK_ENC28J60        (3)
+#define NETWORK_ESP8266     (1)
+#define NETWORK_W5100       (2)
+#define NETWORK_ENC28J60    (3)

-// max size of the WS Message Header
-#define WEBSOCKETS_MAX_HEADER_SIZE  (14)

 // select Network type based
-#if defined(ESP8266) || defined(ESP31B)
+#ifdef ESP8266
 #define WEBSOCKETS_NETWORK_TYPE NETWORK_ESP8266
-//#define WEBSOCKETS_NETWORK_TYPE NETWORK_ESP8266_ASYNC
 #else
 #define WEBSOCKETS_NETWORK_TYPE NETWORK_W5100
 #endif

-#if (WEBSOCKETS_NETWORK_TYPE == NETWORK_ESP8266_ASYNC)

-// Note:
-//   No SSL/WSS support for client in Async mode
-//   TLS lib need a sync interface!
+#if (WEBSOCKETS_NETWORK_TYPE == NETWORK_ESP8266)

-#if !defined(ESP8266) && !defined(ESP31B)
-#error "network type ESP8266 ASYNC only possible on the ESP mcu!"
-#endif
-
-#ifdef ESP8266
-#include <ESP8266WiFi.h>
-#else
-#include <ESP31BWiFi.h>
-#endif
-#include <ESPAsyncTCP.h>
-#include <ESPAsyncTCPbuffer.h>
-#define WEBSOCKETS_NETWORK_CLASS AsyncTCPbuffer
-#define WEBSOCKETS_NETWORK_SERVER_CLASS AsyncServer
-
-#elif (WEBSOCKETS_NETWORK_TYPE == NETWORK_ESP8266)
-
-#if !defined(ESP8266) && !defined(ESP31B)
+#ifndef ESP8266
 #error "network type ESP8266 only possible on the ESP mcu!"
 #endif

-#ifdef ESP8266
 #include <ESP8266WiFi.h>
-#else
-#include <ESP31BWiFi.h>
-#endif
 #define WEBSOCKETS_NETWORK_CLASS WiFiClient
 #define WEBSOCKETS_NETWORK_SERVER_CLASS WiFiServer

@ -137,21 +110,6 @@ typedef enum {
                              ///< %xB-F are reserved for further control frames
 } WSopcode_t;

-typedef struct {
-
-        bool fin;
-        bool rsv1;
-        bool rsv2;
-        bool rsv3;
-
-        WSopcode_t opCode;
-        bool mask;
-
-        size_t payloadLen;
-
-        uint8_t * maskKey;
-} WSMessageHeader_t;
-
 typedef struct {
        uint8_t num; ///< connection number

@ -176,50 +134,26 @@ typedef struct {
        String cExtensions; ///< client Sec-WebSocket-Extensions
        uint16_t cVersion;  ///< client Sec-WebSocket-Version

-        uint8_t cWsRXsize;  ///< State of the RX
-        uint8_t cWsHeader[WEBSOCKETS_MAX_HEADER_SIZE]; ///< RX WS Message buffer
-        WSMessageHeader_t cWsHeaderDecode;
-
-        String base64Authorization; ///< Base64 encoded Auth request
-
-#if (WEBSOCKETS_NETWORK_TYPE == NETWORK_ESP8266_ASYNC)
-        String cHttpLine;   ///< HTTP header lines
-#endif
-
 } WSclient_t;

-
-
 class WebSockets {
    protected:
-#ifdef __AVR__
-        typedef void (*WSreadWaitCb)(WSclient_t * client, bool ok);
-#else
-        typedef std::function<void(WSclient_t * client, bool ok)> WSreadWaitCb;
-#endif
-
        virtual void clientDisconnect(WSclient_t * client);
        virtual bool clientIsConnected(WSclient_t * client);

        virtual void messageRecived(WSclient_t * client, WSopcode_t opcode, uint8_t * payload, size_t length);

        void clientDisconnect(WSclient_t * client, uint16_t code, char * reason = NULL, size_t reasonLen = 0);
-        bool sendFrame(WSclient_t * client, WSopcode_t opcode, uint8_t * payload = NULL, size_t length = 0, bool mask = false, bool fin = true, bool headerToPayload = false);
+        void sendFrame(WSclient_t * client, WSopcode_t opcode, uint8_t * payload = NULL, size_t length = 0, bool mask = false, bool fin = true, bool headerToPayload = false);

-        void headerDone(WSclient_t * client);

        void handleWebsocket(WSclient_t * client);

-        bool handleWebsocketWaitFor(WSclient_t * client, size_t size);
-        void handleWebsocketCb(WSclient_t * client);
-        void handleWebsocketPayloadCb(WSclient_t * client, bool ok, uint8_t * payload);
+        bool readWait(WSclient_t * client, uint8_t *out, size_t n);

-        String acceptKey(String & clientKey);
+        String acceptKey(String clientKey);
        String base64_encode(uint8_t * data, size_t length);

-        bool readCb(WSclient_t * client, uint8_t *out, size_t n, WSreadWaitCb cb);
-
-
 };

 #endif /* WEBSOCKETS_H_ */
--- a/src/WebSocketsClient.cpp
+++ b/src/WebSocketsClient.cpp
@ -25,7 +25,6 @@
 #include "WebSockets.h"
 #include "WebSocketsClient.h"

-
 WebSocketsClient::WebSocketsClient() {
    _cbEvent = NULL;
    _client.num = 0;
@ -38,13 +37,13 @@ WebSocketsClient::~WebSocketsClient() {
 /**
 * calles to init the Websockets server
 */
-void WebSocketsClient::begin(const char *host, uint16_t port, const char * url, const char * protocol) {
+void WebSocketsClient::begin(const char *host, uint16_t port, const char * url) {
    _host = host;
    _port = port;
 #if (WEBSOCKETS_NETWORK_TYPE == NETWORK_ESP8266)
    _fingerprint = "";
 #endif
-
+    
    _client.num = 0;
    _client.status = WSC_NOT_CONNECTED;
    _client.tcp = NULL;
@ -58,10 +57,9 @@ void WebSocketsClient::begin(const char *host, uint16_t port, const char * url,
    _client.cIsWebsocket = true;
    _client.cKey = "";
    _client.cAccept = "";
-    _client.cProtocol = protocol;
+    _client.cProtocol = "";
    _client.cExtensions = "";
    _client.cVersion = 0;
-    _client.base64Authorization = "";

 #ifdef ESP8266
    randomSeed(RANDOM_REG32);
@ -69,29 +67,24 @@ void WebSocketsClient::begin(const char *host, uint16_t port, const char * url,
    // todo find better seed
    randomSeed(millis());
 #endif
-#if (WEBSOCKETS_NETWORK_TYPE == NETWORK_ESP8266_ASYNC)
-    asyncConnect();
-#endif
 }

-void WebSocketsClient::begin(String host, uint16_t port, String url, String protocol) {
-    begin(host.c_str(), port, url.c_str(), protocol.c_str());
+void WebSocketsClient::begin(String host, uint16_t port, String url) {
+    begin(host.c_str(), port, url.c_str());
 }

 #if (WEBSOCKETS_NETWORK_TYPE == NETWORK_ESP8266)
-void WebSocketsClient::beginSSL(const char *host, uint16_t port, const char * url, const char * fingerprint, const char * protocol) {
-    begin(host, port, url, protocol);
+void WebSocketsClient::beginSSL(const char *host, uint16_t port, const char * url, const char * fingerprint) {
+    begin(host, port, url);
    _client.isSSL = true;
    _fingerprint = fingerprint;
 }

-void WebSocketsClient::beginSSL(String host, uint16_t port, String url, String fingerprint, String protocol) {
-    beginSSL(host.c_str(), port, url.c_str(), fingerprint.c_str(), protocol.c_str());
+void WebSocketsClient::beginSSL(String host, uint16_t port, String url, String fingerprint) {
+    beginSSL(host.c_str(), port, url.c_str(), fingerprint.c_str());
 }
 #endif

-
-#if (WEBSOCKETS_NETWORK_TYPE != NETWORK_ESP8266_ASYNC)
 /**
 * called in arduino loop
 */
@ -126,16 +119,36 @@ void WebSocketsClient::loop(void) {
        }

        if(_client.tcp->connect(_host.c_str(), _port)) {
-            connectedCb();
+            DEBUG_WEBSOCKETS("[WS-Client] connected to %s:%u.\n", _host.c_str(), _port);
+
+            _client.status = WSC_HEADER;
+
+            // set Timeout for readBytesUntil and readStringUntil
+            _client.tcp->setTimeout(WEBSOCKETS_TCP_TIMEOUT);
+
+#if (WEBSOCKETS_NETWORK_TYPE == NETWORK_ESP8266)
+            _client.tcp->setNoDelay(true);
+
+            if(_client.isSSL && _fingerprint.length()) {
+                if(!_client.ssl->verify(_fingerprint.c_str(), _host.c_str())) {
+                    DEBUG_WEBSOCKETS("[WS-Client] certificate mismatch\n");
+                    WebSockets::clientDisconnect(&_client, 1000);
+                    return;
+                }
+            }
+#endif
+
+            // send Header to Server
+            sendHeader(&_client);
+
        } else {
-            connectFailedCb();
-            delay(10); //some little delay to not flood the server
+            DEBUG_WEBSOCKETS("[WS-Client] connection to %s:%u Faild\n", _host.c_str(), _port);
+            delay(10); //some litle delay to not flood the server
        }
    } else {
        handleClientData();
    }
 }
-#endif

 /**
 * set callback function
@ -151,32 +164,30 @@ void WebSocketsClient::onEvent(WebSocketClientEvent cbEvent) {
 * @param payload uint8_t *
 * @param length size_t
 * @param headerToPayload bool  (see sendFrame for more details)
- * @return true if ok
 */
-bool WebSocketsClient::sendTXT(uint8_t * payload, size_t length, bool headerToPayload) {
+void WebSocketsClient::sendTXT(uint8_t * payload, size_t length, bool headerToPayload) {
    if(length == 0) {
        length = strlen((const char *) payload);
    }
    if(clientIsConnected(&_client)) {
-        return sendFrame(&_client, WSop_text, payload, length, true, true, headerToPayload);
+        sendFrame(&_client, WSop_text, payload, length, true, true, headerToPayload);
    }
-    return false;
 }

-bool WebSocketsClient::sendTXT(const uint8_t * payload, size_t length) {
-    return sendTXT((uint8_t *) payload, length);
+void WebSocketsClient::sendTXT(const uint8_t * payload, size_t length) {
+    sendTXT((uint8_t *) payload, length);
 }

-bool WebSocketsClient::sendTXT(char * payload, size_t length, bool headerToPayload) {
-    return sendTXT((uint8_t *) payload, length, headerToPayload);
+void WebSocketsClient::sendTXT(char * payload, size_t length, bool headerToPayload) {
+    sendTXT((uint8_t *) payload, length, headerToPayload);
 }

-bool WebSocketsClient::sendTXT(const char * payload, size_t length) {
-    return sendTXT((uint8_t *) payload, length);
+void WebSocketsClient::sendTXT(const char * payload, size_t length) {
+    sendTXT((uint8_t *) payload, length);
 }

-bool WebSocketsClient::sendTXT(String & payload) {
-    return sendTXT((uint8_t *) payload.c_str(), payload.length());
+void WebSocketsClient::sendTXT(String payload) {
+    sendTXT((uint8_t *) payload.c_str(), payload.length());
 }

 /**
@ -185,17 +196,15 @@ bool WebSocketsClient::sendTXT(String & payload) {
 * @param payload uint8_t *
 * @param length size_t
 * @param headerToPayload bool  (see sendFrame for more details)
- * @return true if ok
 */
-bool WebSocketsClient::sendBIN(uint8_t * payload, size_t length, bool headerToPayload) {
+void WebSocketsClient::sendBIN(uint8_t * payload, size_t length, bool headerToPayload) {
    if(clientIsConnected(&_client)) {
-        return sendFrame(&_client, WSop_binary, payload, length, true, true, headerToPayload);
+        sendFrame(&_client, WSop_binary, payload, length, true, true, headerToPayload);
    }
-    return false;
 }

-bool WebSocketsClient::sendBIN(const uint8_t * payload, size_t length) {
-    return sendBIN((uint8_t *) payload, length);
+void WebSocketsClient::sendBIN(const uint8_t * payload, size_t length) {
+    sendBIN((uint8_t *) payload, length);
 }

 /**
@ -208,30 +217,6 @@ void WebSocketsClient::disconnect(void) {
    }
 }

-/**
- * set the Authorizatio for the http request
- * @param user const char *
- * @param password const char *
- */
-void WebSocketsClient::setAuthorization(const char * user, const char * password) {
-    if(user && password) {
-        String auth = user;
-        auth += ":";
-        auth += password;
-        _client.base64Authorization = base64_encode((uint8_t *)auth.c_str(), auth.length());
-    }
-}
-
-/**
- * set the Authorizatio for the http request
- * @param auth const char * base64
- */
-void WebSocketsClient::setAuthorization(const char * auth) {
-    if(auth) {
-        _client.base64Authorization = auth;
-    }
-}
-
 //#################################################################################
 //#################################################################################
 //#################################################################################
@ -265,15 +250,12 @@ void WebSocketsClient::messageRecived(WSclient_t * client, WSopcode_t opcode, ui
 */
 void WebSocketsClient::clientDisconnect(WSclient_t * client) {

-    bool event = false;
-
 #if (WEBSOCKETS_NETWORK_TYPE == NETWORK_ESP8266)
    if(client->isSSL && client->ssl) {
        if(client->ssl->connected()) {
            client->ssl->flush();
            client->ssl->stop();
        }
-        event = true;
        delete client->ssl;
        client->ssl = NULL;
        client->tcp = NULL;
@ -282,17 +264,10 @@ void WebSocketsClient::clientDisconnect(WSclient_t * client) {

    if(client->tcp) {
        if(client->tcp->connected()) {
-#if (WEBSOCKETS_NETWORK_TYPE != NETWORK_ESP8266_ASYNC)
            client->tcp->flush();
-#endif
            client->tcp->stop();
        }
-        event = true;
-#if (WEBSOCKETS_NETWORK_TYPE == NETWORK_ESP8266_ASYNC)
-        client->status = WSC_NOT_CONNECTED;
-#else
        delete client->tcp;
-#endif
        client->tcp = NULL;
    }

@ -307,9 +282,9 @@ void WebSocketsClient::clientDisconnect(WSclient_t * client) {
    client->status = WSC_NOT_CONNECTED;

    DEBUG_WEBSOCKETS("[WS-Client] client disconnected.\n");
-    if(event) {
-        runCbEvent(WStype_DISCONNECTED, NULL, 0);
-    }
+
+    runCbEvent(WStype_DISCONNECTED, NULL, 0);
+
 }

 /**
@ -343,7 +318,7 @@ bool WebSocketsClient::clientIsConnected(WSclient_t * client) {

    return false;
 }
-#if (WEBSOCKETS_NETWORK_TYPE != NETWORK_ESP8266_ASYNC)
+
 /**
 * Handel incomming data from Client
 */
@ -352,10 +327,7 @@ void WebSocketsClient::handleClientData(void) {
    if(len > 0) {
        switch(_client.status) {
            case WSC_HEADER:
-            {
-                String headerLine = _client.tcp->readStringUntil('\n');
-                handleHeader(&_client, &headerLine);
-            }
+                handleHeader(&_client);
                break;
            case WSC_CONNECTED:
                WebSockets::handleWebsocket(&_client);
@ -365,11 +337,10 @@ void WebSocketsClient::handleClientData(void) {
                break;
        }
    }
-#if (WEBSOCKETS_NETWORK_TYPE == NETWORK_ESP8266)
+#ifdef ESP8266
    delay(0);
 #endif
 }
-#endif

 /**
 * send the WebSocket header to Server
@ -397,25 +368,17 @@ void WebSocketsClient::sendHeader(WSclient_t * client) {
                        "Connection: Upgrade\r\n"
                        "User-Agent: arduino-WebSocket-Client\r\n"
                        "Sec-WebSocket-Version: 13\r\n"
-                        "Sec-WebSocket-Protocol: " + client->cProtocol +"\r\n"
+                        "Sec-WebSocket-Protocol: arduino\r\n"
                        "Sec-WebSocket-Key: " + client->cKey + "\r\n";

    if(client->cExtensions.length() > 0) {
        handshake += "Sec-WebSocket-Extensions: " + client->cExtensions + "\r\n";
    }

-    if(client->base64Authorization.length() > 0) {
-        handshake += "Authorization: Basic " + client->base64Authorization + "\r\n";
-    }
-
    handshake += "\r\n";

    client->tcp->write(handshake.c_str(), handshake.length());

-#if (WEBSOCKETS_NETWORK_TYPE == NETWORK_ESP8266_ASYNC)
-        client->tcp->readStringUntil('\n', &(client->cHttpLine), std::bind(&WebSocketsClient::handleHeader, this, client, &(client->cHttpLine)));
-#endif
-
    DEBUG_WEBSOCKETS("[WS-Client][sendHeader] sending header... Done (%uus).\n", (micros() - start));

 }
@ -424,22 +387,23 @@ void WebSocketsClient::sendHeader(WSclient_t * client) {
 * handle the WebSocket header reading
 * @param client WSclient_t *  ptr to the client struct
 */
-void WebSocketsClient::handleHeader(WSclient_t * client, String * headerLine) {
+void WebSocketsClient::handleHeader(WSclient_t * client) {

-    headerLine->trim(); // remove \r
+    String headerLine = client->tcp->readStringUntil('\n');
+    headerLine.trim(); // remove \r

-    if(headerLine->length() > 0) {
-        DEBUG_WEBSOCKETS("[WS-Client][handleHeader] RX: %s\n", headerLine->c_str());
+    if(headerLine.length() > 0) {
+        DEBUG_WEBSOCKETS("[WS-Client][handleHeader] RX: %s\n", headerLine.c_str());

-        if(headerLine->startsWith("HTTP/1.")) {
+        if(headerLine.startsWith("HTTP/1.")) {
            // "HTTP/1.1 101 Switching Protocols"
-            client->cCode = headerLine->substring(9, headerLine->indexOf(' ', 9)).toInt();
-        } else if(headerLine->indexOf(':')) {
-            String headerName = headerLine->substring(0, headerLine->indexOf(':'));
-            String headerValue = headerLine->substring(headerLine->indexOf(':') + 2);
+            client->cCode = headerLine.substring(9, headerLine.indexOf(' ', 9)).toInt();
+        } else if(headerLine.indexOf(':')) {
+            String headerName = headerLine.substring(0, headerLine.indexOf(':'));
+            String headerValue = headerLine.substring(headerLine.indexOf(':') + 2);

            if(headerName.equalsIgnoreCase("Connection")) {
-                if(headerValue.indexOf("Upgrade") >= 0) {
+                if(headerValue.equalsIgnoreCase("Upgrade")) {
                    client->cIsUpgrade = true;
                }
            } else if(headerName.equalsIgnoreCase("Upgrade")) {
@ -457,14 +421,9 @@ void WebSocketsClient::handleHeader(WSclient_t * client, String * headerLine) {
                client->cVersion = headerValue.toInt();
            }
        } else {
-            DEBUG_WEBSOCKETS("[WS-Client][handleHeader] Header error (%s)\n", headerLine->c_str());
+            DEBUG_WEBSOCKETS("[WS-Client][handleHeader] Header error (%s)\n", headerLine.c_str());
        }

-        (*headerLine) = "";
-#if (WEBSOCKETS_NETWORK_TYPE == NETWORK_ESP8266_ASYNC)
-        client->tcp->readStringUntil('\n', &(client->cHttpLine), std::bind(&WebSocketsClient::handleHeader, this, client, &(client->cHttpLine)));
-#endif
-
    } else {
        DEBUG_WEBSOCKETS("[WS-Client][handleHeader] Header read fin.\n");
        DEBUG_WEBSOCKETS("[WS-Client][handleHeader] Client settings:\n");
@ -499,7 +458,6 @@ void WebSocketsClient::handleHeader(WSclient_t * client, String * headerLine) {
        }

        if(ok) {
-
            if(client->cAccept.length() == 0) {
                ok = false;
            } else {
@ -515,8 +473,8 @@ void WebSocketsClient::handleHeader(WSclient_t * client, String * headerLine) {
        if(ok) {

            DEBUG_WEBSOCKETS("[WS-Client][handleHeader] Websocket connection init done.\n");
-            headerDone(client);

+            client->status = WSC_CONNECTED;

            runCbEvent(WStype_CONNECTED, (uint8_t *) client->cUrl.c_str(), client->cUrl.length());

@ -528,95 +486,3 @@ void WebSocketsClient::handleHeader(WSclient_t * client, String * headerLine) {
    }
 }

-void WebSocketsClient::connectedCb() {
-
-    DEBUG_WEBSOCKETS("[WS-Client] connected to %s:%u.\n", _host.c_str(), _port);
-
-#if (WEBSOCKETS_NETWORK_TYPE == NETWORK_ESP8266_ASYNC)
-    _client.tcp->onDisconnect(std::bind([](WebSocketsClient * c, AsyncTCPbuffer * obj, WSclient_t * client) -> bool {
-        DEBUG_WEBSOCKETS("[WS-Server][%d] Disconnect client\n", client->num);
-        client->status = WSC_NOT_CONNECTED;
-        client->tcp = NULL;
-
-        // reconnect
-        c->asyncConnect();
-
-        return true;
-    }, this, std::placeholders::_1, &_client));
-#endif
-
-    _client.status = WSC_HEADER;
-
-#if (WEBSOCKETS_NETWORK_TYPE != NETWORK_ESP8266_ASYNC)
-    // set Timeout for readBytesUntil and readStringUntil
-    _client.tcp->setTimeout(WEBSOCKETS_TCP_TIMEOUT);
-#endif
-
-#if (WEBSOCKETS_NETWORK_TYPE == NETWORK_ESP8266)
-    _client.tcp->setNoDelay(true);
-
-    if(_client.isSSL && _fingerprint.length()) {
-        if(!_client.ssl->verify(_fingerprint.c_str(), _host.c_str())) {
-            DEBUG_WEBSOCKETS("[WS-Client] certificate mismatch\n");
-            WebSockets::clientDisconnect(&_client, 1000);
-            return;
-        }
-    }
-#endif
-
-    // send Header to Server
-    sendHeader(&_client);
-
-}
-
-
-void WebSocketsClient::connectFailedCb() {
-    DEBUG_WEBSOCKETS("[WS-Client] connection to %s:%u Faild\n", _host.c_str(), _port);
-}
-
-#if (WEBSOCKETS_NETWORK_TYPE == NETWORK_ESP8266_ASYNC)
-
-void WebSocketsClient::asyncConnect() {
-
-    DEBUG_WEBSOCKETS("[WS-Client] asyncConnect...\n");
-
-    AsyncClient * tcpclient = new AsyncClient();
-
-    if(!tcpclient) {
-        DEBUG_WEBSOCKETS("[WS-Client] creating AsyncClient class failed!\n");
-        return;
-    }
-
-    tcpclient->onDisconnect([](void *obj, AsyncClient* c) {
-        c->free();
-        delete c;
-    });
-
-    tcpclient->onConnect(std::bind([](WebSocketsClient * ws , AsyncClient * tcp) {
-        ws->_client.tcp = new AsyncTCPbuffer(tcp);
-        if(!ws->_client.tcp) {
-            DEBUG_WEBSOCKETS("[WS-Client] creating Network class failed!\n");
-            ws->connectFailedCb();
-            return;
-        }
-        ws->connectedCb();
-    }, this, std::placeholders::_2));
-
-    tcpclient->onError(std::bind([](WebSocketsClient * ws , AsyncClient * tcp) {
-        ws->connectFailedCb();
-
-        // reconnect
-        ws->asyncConnect();
-    }, this, std::placeholders::_2));
-
-    if(!tcpclient->connect(_host.c_str(), _port)) {
-        connectFailedCb();
-        delete tcpclient;
-    }
-
-}
-
-#endif
-
-
-
--- a/src/WebSocketsClient.h
+++ b/src/WebSocketsClient.h
@ -30,47 +30,35 @@

 class WebSocketsClient: private WebSockets {
    public:
-#ifdef __AVR__
-        typedef void (*WebSocketClientEvent)(WStype_t type, uint8_t * payload, size_t length);
-#else
-        typedef std::function<void (WStype_t type, uint8_t * payload, size_t length)> WebSocketClientEvent;
-#endif

+        typedef void (*WebSocketClientEvent)(WStype_t type, uint8_t * payload, size_t length);

        WebSocketsClient(void);
        ~WebSocketsClient(void);

-        void begin(const char *host, uint16_t port, const char * url = "/", const char * protocol = "arduino");
-        void begin(String host, uint16_t port, String url = "/", String protocol = "arduino");
+        void begin(const char *host, uint16_t port, const char * url = "/");
+        void begin(String host, uint16_t port, String url = "/");

 #if (WEBSOCKETS_NETWORK_TYPE == NETWORK_ESP8266)
-        void beginSSL(const char *host, uint16_t port, const char * url = "/", const char * = "", const char * protocol = "arduino");
-        void beginSSL(String host, uint16_t port, String url = "/", String fingerprint = "", String protocol = "arduino");
+        void beginSSL(const char *host, uint16_t port, const char * url = "/", const char * = "");
+        void beginSSL(String host, uint16_t port, String url = "/", String fingerprint = "");
 #endif

-#if (WEBSOCKETS_NETWORK_TYPE != NETWORK_ESP8266_ASYNC)
        void loop(void);
-#else
-        // Async interface not need a loop call
-        void loop(void) __attribute__ ((deprecated)) {}
-#endif

        void onEvent(WebSocketClientEvent cbEvent);

-        bool sendTXT(uint8_t * payload, size_t length = 0, bool headerToPayload = false);
-        bool sendTXT(const uint8_t * payload, size_t length = 0);
-        bool sendTXT(char * payload, size_t length = 0, bool headerToPayload = false);
-        bool sendTXT(const char * payload, size_t length = 0);
-        bool sendTXT(String & payload);
+        void sendTXT(uint8_t * payload, size_t length = 0, bool headerToPayload = false);
+        void sendTXT(const uint8_t * payload, size_t length = 0);
+        void sendTXT(char * payload, size_t length = 0, bool headerToPayload = false);
+        void sendTXT(const char * payload, size_t length = 0);
+        void sendTXT(String payload);

-        bool sendBIN(uint8_t * payload, size_t length, bool headerToPayload = false);
-        bool sendBIN(const uint8_t * payload, size_t length);
+        void sendBIN(uint8_t * payload, size_t length, bool headerToPayload = false);
+        void sendBIN(const uint8_t * payload, size_t length);

        void disconnect(void);

-        void setAuthorization(const char * user, const char * password);
-        void setAuthorization(const char * auth);
-
    protected:
        String _host;
        uint16_t _port;
@ -87,19 +75,11 @@ class WebSocketsClient: private WebSockets {
        void clientDisconnect(WSclient_t * client);
        bool clientIsConnected(WSclient_t * client);

-#if (WEBSOCKETS_NETWORK_TYPE != NETWORK_ESP8266_ASYNC)
+        void handleNewClients(void);
        void handleClientData(void);
-#endif

        void sendHeader(WSclient_t * client);
-        void handleHeader(WSclient_t * client, String * headerLine);
-
-        void connectedCb();
-        void connectFailedCb();
-
-#if (WEBSOCKETS_NETWORK_TYPE == NETWORK_ESP8266_ASYNC)
-        void asyncConnect();
-#endif
+        void handleHeader(WSclient_t * client);

        /**
         * called for sending a Event to the app
--- a/src/WebSocketsServer.cpp
+++ b/src/WebSocketsServer.cpp
@ -25,34 +25,19 @@
 #include "WebSockets.h"
 #include "WebSocketsServer.h"

-WebSocketsServer::WebSocketsServer(uint16_t port, String origin, String protocol) {
+WebSocketsServer::WebSocketsServer(uint16_t port) {
    _port = port;
-    _origin = origin;
-    _protocol = protocol;
-
    _server = new WEBSOCKETS_NETWORK_SERVER_CLASS(port);

-#if (WEBSOCKETS_NETWORK_TYPE == NETWORK_ESP8266_ASYNC)
-    _server->onClient([](void *s, AsyncClient* c){
-        ((WebSocketsServer*)s)->newClient(new AsyncTCPbuffer(c));
-    }, this);
-#endif
-
    _cbEvent = NULL;

 }

-
 WebSocketsServer::~WebSocketsServer() {
    // disconnect all clients
    disconnect();

-#if (WEBSOCKETS_NETWORK_TYPE == NETWORK_ESP8266)
-    _server->close();
-#else
    // TODO how to close server?
-#endif
-
 }

 /**
@ -79,13 +64,6 @@ void WebSocketsServer::begin(void) {
        client->cVersion = 0;
        client->cIsUpgrade = false;
        client->cIsWebsocket = false;
-
-        client->base64Authorization = "";
-
-        client->cWsRXsize = 0;
-#if (WEBSOCKETS_NETWORK_TYPE == NETWORK_ESP8266_ASYNC)
-        client->cHttpLine = "";
-#endif
    }

 #ifdef ESP8266
@ -100,7 +78,6 @@ void WebSocketsServer::begin(void) {
    DEBUG_WEBSOCKETS("[WS-Server] Server Started.\n");
 }

-#if (WEBSOCKETS_NETWORK_TYPE != NETWORK_ESP8266_ASYNC)
 /**
 * called in arduino loop
 */
@ -108,7 +85,6 @@ void WebSocketsServer::loop(void) {
    handleNewClients();
    handleClientData();
 }
-#endif

 /**
 * set callback function
@ -124,36 +100,34 @@ void WebSocketsServer::onEvent(WebSocketServerEvent cbEvent) {
 * @param payload uint8_t *
 * @param length size_t
 * @param headerToPayload bool  (see sendFrame for more details)
- * @return true if ok
 */
-bool WebSocketsServer::sendTXT(uint8_t num, uint8_t * payload, size_t length, bool headerToPayload) {
+void WebSocketsServer::sendTXT(uint8_t num, uint8_t * payload, size_t length, bool headerToPayload) {
    if(num >= WEBSOCKETS_SERVER_CLIENT_MAX) {
-        return false;
+        return;
    }
    if(length == 0) {
        length = strlen((const char *) payload);
    }
    WSclient_t * client = &_clients[num];
    if(clientIsConnected(client)) {
-        return sendFrame(client, WSop_text, payload, length, false, true, headerToPayload);
+        sendFrame(client, WSop_text, payload, length, false, true, headerToPayload);
    }
-    return false;
 }

-bool WebSocketsServer::sendTXT(uint8_t num, const uint8_t * payload, size_t length) {
-    return sendTXT(num, (uint8_t *) payload, length);
+void WebSocketsServer::sendTXT(uint8_t num, const uint8_t * payload, size_t length) {
+    sendTXT(num, (uint8_t *) payload, length);
 }

-bool WebSocketsServer::sendTXT(uint8_t num, char * payload, size_t length, bool headerToPayload) {
-    return sendTXT(num, (uint8_t *) payload, length, headerToPayload);
+void WebSocketsServer::sendTXT(uint8_t num, char * payload, size_t length, bool headerToPayload) {
+    sendTXT(num, (uint8_t *) payload, length, headerToPayload);
 }

-bool WebSocketsServer::sendTXT(uint8_t num, const char * payload, size_t length) {
-    return sendTXT(num, (uint8_t *) payload, length);
+void WebSocketsServer::sendTXT(uint8_t num, const char * payload, size_t length) {
+    sendTXT(num, (uint8_t *) payload, length);
 }

-bool WebSocketsServer::sendTXT(uint8_t num, String & payload) {
-    return sendTXT(num, (uint8_t *) payload.c_str(), payload.length());
+void WebSocketsServer::sendTXT(uint8_t num, String payload) {
+    sendTXT(num, (uint8_t *) payload.c_str(), payload.length());
 }

 /**
@ -161,11 +135,9 @@ bool WebSocketsServer::sendTXT(uint8_t num, String & payload) {
 * @param payload uint8_t *
 * @param length size_t
 * @param headerToPayload bool  (see sendFrame for more details)
- * @return true if ok
 */
-bool WebSocketsServer::broadcastTXT(uint8_t * payload, size_t length, bool headerToPayload) {
+void WebSocketsServer::broadcastTXT(uint8_t * payload, size_t length, bool headerToPayload) {
    WSclient_t * client;
-    bool ret = true;
    if(length == 0) {
        length = strlen((const char *) payload);
    }
@ -173,31 +145,28 @@ bool WebSocketsServer::broadcastTXT(uint8_t * payload, size_t length, bool heade
    for(uint8_t i = 0; i < WEBSOCKETS_SERVER_CLIENT_MAX; i++) {
        client = &_clients[i];
        if(clientIsConnected(client)) {
-            if(!sendFrame(client, WSop_text, payload, length, false, true, headerToPayload)) {
-                ret = false;
-            }
+            sendFrame(client, WSop_text, payload, length, false, true, headerToPayload);
        }
-#if (WEBSOCKETS_NETWORK_TYPE == NETWORK_ESP8266)
+#ifdef ESP8266
        delay(0);
 #endif
    }
-    return ret;
 }

-bool WebSocketsServer::broadcastTXT(const uint8_t * payload, size_t length) {
-    return broadcastTXT((uint8_t *) payload, length);
+void WebSocketsServer::broadcastTXT(const uint8_t * payload, size_t length) {
+    broadcastTXT((uint8_t *) payload, length);
 }

-bool WebSocketsServer::broadcastTXT(char * payload, size_t length, bool headerToPayload) {
-    return broadcastTXT((uint8_t *) payload, length, headerToPayload);
+void WebSocketsServer::broadcastTXT(char * payload, size_t length, bool headerToPayload) {
+    broadcastTXT((uint8_t *) payload, length, headerToPayload);
 }

-bool WebSocketsServer::broadcastTXT(const char * payload, size_t length) {
-    return broadcastTXT((uint8_t *) payload, length);
+void WebSocketsServer::broadcastTXT(const char * payload, size_t length) {
+    broadcastTXT((uint8_t *) payload, length);
 }

-bool WebSocketsServer::broadcastTXT(String & payload) {
-    return broadcastTXT((uint8_t *) payload.c_str(), payload.length());
+void WebSocketsServer::broadcastTXT(String payload) {
+    broadcastTXT((uint8_t *) payload.c_str(), payload.length());
 }

 /**
@ -206,21 +175,19 @@ bool WebSocketsServer::broadcastTXT(String & payload) {
 * @param payload uint8_t *
 * @param length size_t
 * @param headerToPayload bool  (see sendFrame for more details)
- * @return true if ok
 */
-bool WebSocketsServer::sendBIN(uint8_t num, uint8_t * payload, size_t length, bool headerToPayload) {
+void WebSocketsServer::sendBIN(uint8_t num, uint8_t * payload, size_t length, bool headerToPayload) {
    if(num >= WEBSOCKETS_SERVER_CLIENT_MAX) {
-        return false;
+        return;
    }
    WSclient_t * client = &_clients[num];
    if(clientIsConnected(client)) {
-        return sendFrame(client, WSop_binary, payload, length, false, true, headerToPayload);
+        sendFrame(client, WSop_binary, payload, length, false, true, headerToPayload);
    }
-    return false;
 }

-bool WebSocketsServer::sendBIN(uint8_t num, const uint8_t * payload, size_t length) {
-    return sendBIN(num, (uint8_t *) payload, length);
+void WebSocketsServer::sendBIN(uint8_t num, const uint8_t * payload, size_t length) {
+    sendBIN(num, (uint8_t *) payload, length);
 }

 /**
@ -228,27 +195,22 @@ bool WebSocketsServer::sendBIN(uint8_t num, const uint8_t * payload, size_t leng
 * @param payload uint8_t *
 * @param length size_t
 * @param headerToPayload bool  (see sendFrame for more details)
- * @return true if ok
 */
-bool WebSocketsServer::broadcastBIN(uint8_t * payload, size_t length, bool headerToPayload) {
+void WebSocketsServer::broadcastBIN(uint8_t * payload, size_t length, bool headerToPayload) {
    WSclient_t * client;
-    bool ret = true;
    for(uint8_t i = 0; i < WEBSOCKETS_SERVER_CLIENT_MAX; i++) {
        client = &_clients[i];
        if(clientIsConnected(client)) {
-            if(!sendFrame(client, WSop_binary, payload, length, false, true, headerToPayload)) {
-                ret = false;
-            }
+            sendFrame(client, WSop_binary, payload, length, false, true, headerToPayload);
        }
-#if (WEBSOCKETS_NETWORK_TYPE == NETWORK_ESP8266)
+#ifdef ESP8266
        delay(0);
 #endif
    }
-    return ret;
 }

-bool WebSocketsServer::broadcastBIN(const uint8_t * payload, size_t length) {
-    return broadcastBIN((uint8_t *) payload, length);
+void WebSocketsServer::broadcastBIN(const uint8_t * payload, size_t length) {
+    broadcastBIN((uint8_t *) payload, length);
 }

 /**
@ -278,33 +240,7 @@ void WebSocketsServer::disconnect(uint8_t num) {
    }
 }

-
-
-/**
- * set the Authorizatio for the http request
- * @param user const char *
- * @param password const char *
- */
-void WebSocketsServer::setAuthorization(const char * user, const char * password) {
-    if(user && password) {
-        String auth = user;
-        auth += ":";
-        auth += password;
-        _base64Authorization = base64_encode((uint8_t *)auth.c_str(), auth.length());
-    }
-}
-
-/**
- * set the Authorizatio for the http request
- * @param auth const char * base64
- */
-void WebSocketsServer::setAuthorization(const char * auth) {
-    if(auth) {
-        _base64Authorization = auth;
-    }
-}
-
-#if (WEBSOCKETS_NETWORK_TYPE == NETWORK_ESP8266) || (WEBSOCKETS_NETWORK_TYPE == NETWORK_ESP8266_ASYNC)
+#if (WEBSOCKETS_NETWORK_TYPE == NETWORK_ESP8266)
 /**
 * get an IP for a client
 * @param num uint8_t client id
@ -326,61 +262,6 @@ IPAddress WebSocketsServer::remoteIP(uint8_t num) {
 //#################################################################################
 //#################################################################################

-/**
- * handle new client connection
- * @param client
- */
-bool WebSocketsServer::newClient(WEBSOCKETS_NETWORK_CLASS * TCPclient) {
-    WSclient_t * client;
-    // search free list entry for client
-    for(uint8_t i = 0; i < WEBSOCKETS_SERVER_CLIENT_MAX; i++) {
-        client = &_clients[i];
-
-        // state is not connected or tcp connection is lost
-        if(!clientIsConnected(client)) {
-
-            client->tcp = TCPclient;
-
-#if (WEBSOCKETS_NETWORK_TYPE == NETWORK_ESP8266)
-            client->isSSL = false;
-            client->tcp->setNoDelay(true);
-#endif
-#if (WEBSOCKETS_NETWORK_TYPE != NETWORK_ESP8266_ASYNC)
-            // set Timeout for readBytesUntil and readStringUntil
-            client->tcp->setTimeout(WEBSOCKETS_TCP_TIMEOUT);
-#endif
-            client->status = WSC_HEADER;
-#if (WEBSOCKETS_NETWORK_TYPE == NETWORK_ESP8266) || (WEBSOCKETS_NETWORK_TYPE == NETWORK_ESP8266_ASYNC)
-            IPAddress ip = client->tcp->remoteIP();
-            DEBUG_WEBSOCKETS("[WS-Server][%d] new client from %d.%d.%d.%d\n", client->num, ip[0], ip[1], ip[2], ip[3]);
-#else
-            DEBUG_WEBSOCKETS("[WS-Server][%d] new client\n", client->num);
-#endif
-
-
-#if (WEBSOCKETS_NETWORK_TYPE == NETWORK_ESP8266_ASYNC)
-            client->tcp->onDisconnect(std::bind([](WebSocketsServer * server, AsyncTCPbuffer * obj, WSclient_t * client) -> bool {
-                DEBUG_WEBSOCKETS("[WS-Server][%d] Disconnect client\n", client->num);
-
-                AsyncTCPbuffer ** sl = &server->_clients[client->num].tcp;
-                if(*sl == obj) {
-                    client->status = WSC_NOT_CONNECTED;
-                    *sl = NULL;
-                }
-                return true;
-            },  this, std::placeholders::_1, client));
-
-
-            client->tcp->readStringUntil('\n', &(client->cHttpLine), std::bind(&WebSocketsServer::handleHeader, this, client, &(client->cHttpLine)));
-#endif
-
-            return true;
-            break;
-        }
-    }
-    return false;
-}
-
 /**
 *
 * @param client WSclient_t *  ptr to the client struct
@ -425,16 +306,10 @@ void WebSocketsServer::clientDisconnect(WSclient_t * client) {

    if(client->tcp) {
        if(client->tcp->connected()) {
-#if (WEBSOCKETS_NETWORK_TYPE != NETWORK_ESP8266_ASYNC)
            client->tcp->flush();
-#endif
            client->tcp->stop();
        }
-#if (WEBSOCKETS_NETWORK_TYPE == NETWORK_ESP8266_ASYNC)
-        client->status = WSC_NOT_CONNECTED;
-#else
        delete client->tcp;
-#endif
        client->tcp = NULL;
    }

@ -445,11 +320,6 @@ void WebSocketsServer::clientDisconnect(WSclient_t * client) {
    client->cIsUpgrade = false;
    client->cIsWebsocket = false;

-    client->cWsRXsize = 0;
-#if (WEBSOCKETS_NETWORK_TYPE == NETWORK_ESP8266_ASYNC)
-    client->cHttpLine = "";
-#endif
-
    client->status = WSC_NOT_CONNECTED;

    DEBUG_WEBSOCKETS("[WS-Server][%d] client disconnected.\n", client->num);
@ -484,56 +354,76 @@ bool WebSocketsServer::clientIsConnected(WSclient_t * client) {

    if(client->tcp) {
        // do cleanup
-        DEBUG_WEBSOCKETS("[WS-Server][%d] client list cleanup.\n", client->num);
        clientDisconnect(client);
    }

    return false;
 }
-#if (WEBSOCKETS_NETWORK_TYPE != NETWORK_ESP8266_ASYNC)
+
 /**
 * Handle incomming Connection Request
 */
 void WebSocketsServer::handleNewClients(void) {
-
+    WSclient_t * client;
 #if (WEBSOCKETS_NETWORK_TYPE == NETWORK_ESP8266)
    while(_server->hasClient()) {
 #endif
        bool ok = false;
+        // search free list entry for client
+        for(uint8_t i = 0; i < WEBSOCKETS_SERVER_CLIENT_MAX; i++) {
+            client = &_clients[i];
+
+            // state is not connected or tcp connection is lost
+            if(!clientIsConnected(client)) {
+#if (WEBSOCKETS_NETWORK_TYPE == NETWORK_ESP8266)
+                // store new connection
+                client->tcp = new WEBSOCKETS_NETWORK_CLASS(_server->available());
+#else
+                client->tcp = new WEBSOCKETS_NETWORK_CLASS(_server->available());
+#endif
+                if(!client->tcp) {
+                    DEBUG_WEBSOCKETS("[WS-Client] creating Network class failed!");
+                    return;
+                }

 #if (WEBSOCKETS_NETWORK_TYPE == NETWORK_ESP8266)
-        // store new connection
-        WEBSOCKETS_NETWORK_CLASS * tcpClient = new WEBSOCKETS_NETWORK_CLASS(_server->available());
-#else
-        WEBSOCKETS_NETWORK_CLASS * tcpClient = new WEBSOCKETS_NETWORK_CLASS(_server->available());
+                client->isSSL = false;
+                client->tcp->setNoDelay(true);
 #endif
-
-        if(!tcpClient) {
-            DEBUG_WEBSOCKETS("[WS-Client] creating Network class failed!");
-            return;
+                // set Timeout for readBytesUntil and readStringUntil
+                client->tcp->setTimeout(WEBSOCKETS_TCP_TIMEOUT);
+                client->status = WSC_HEADER;
+#if (WEBSOCKETS_NETWORK_TYPE == NETWORK_ESP8266)
+                IPAddress ip = client->tcp->remoteIP();
+                DEBUG_WEBSOCKETS("[WS-Server][%d] new client from %d.%d.%d.%d\n", client->num, ip[0], ip[1], ip[2], ip[3]);
+#else
+                DEBUG_WEBSOCKETS("[WS-Server][%d] new client\n", client->num);
+#endif
+                ok = true;
+                break;
+            }
        }

-        ok = newClient(tcpClient);
-
        if(!ok) {
            // no free space to handle client
+            WEBSOCKETS_NETWORK_CLASS tcpClient = _server->available();
 #if (WEBSOCKETS_NETWORK_TYPE == NETWORK_ESP8266)
-            IPAddress ip = tcpClient->remoteIP();
+            IPAddress ip = client->tcp->remoteIP();
            DEBUG_WEBSOCKETS("[WS-Server] no free space new client from %d.%d.%d.%d\n", ip[0], ip[1], ip[2], ip[3]);
 #else
            DEBUG_WEBSOCKETS("[WS-Server] no free space new client\n");
 #endif
-            tcpClient->stop();
+            tcpClient.stop();
        }

-#if (WEBSOCKETS_NETWORK_TYPE == NETWORK_ESP8266)
+#ifdef ESP8266
        delay(0);
+#endif
+#if (WEBSOCKETS_NETWORK_TYPE == NETWORK_ESP8266)
    }
 #endif
-
 }

-
 /**
 * Handel incomming data from Client
 */
@ -545,13 +435,10 @@ void WebSocketsServer::handleClientData(void) {
        if(clientIsConnected(client)) {
            int len = client->tcp->available();
            if(len > 0) {
-                //DEBUG_WEBSOCKETS("[WS-Server][%d][handleClientData] len: %d\n", client->num, len);
+
                switch(client->status) {
                    case WSC_HEADER:
-                    {
-                        String headerLine = client->tcp->readStringUntil('\n');
-                        handleHeader(client, &headerLine);
-                    }
+                        handleHeader(client);
                        break;
                    case WSC_CONNECTED:
                        WebSockets::handleWebsocket(client);
@ -562,32 +449,31 @@ void WebSocketsServer::handleClientData(void) {
                }
            }
        }
-#if (WEBSOCKETS_NETWORK_TYPE == NETWORK_ESP8266)
+#ifdef ESP8266
        delay(0);
 #endif
    }
 }
-#endif
-

 /**
 * handle the WebSocket header reading
 * @param client WSclient_t *  ptr to the client struct
 */
-void WebSocketsServer::handleHeader(WSclient_t * client, String * headerLine) {
+void WebSocketsServer::handleHeader(WSclient_t * client) {

-    headerLine->trim(); // remove \r
+    String headerLine = client->tcp->readStringUntil('\n');
+    headerLine.trim(); // remove \r

-    if(headerLine->length() > 0) {
-        DEBUG_WEBSOCKETS("[WS-Server][%d][handleHeader] RX: %s\n", client->num, headerLine->c_str());
+    if(headerLine.length() > 0) {
+        DEBUG_WEBSOCKETS("[WS-Server][%d][handleHeader] RX: %s\n", client->num, headerLine.c_str());

        // websocket request starts allways with GET see rfc6455
-        if(headerLine->startsWith("GET ")) {
+        if(headerLine.startsWith("GET ")) {
            // cut URL out
-            client->cUrl = headerLine->substring(4, headerLine->indexOf(' ', 4));
-        } else if(headerLine->indexOf(':')) {
-            String headerName = headerLine->substring(0, headerLine->indexOf(':'));
-            String headerValue = headerLine->substring(headerLine->indexOf(':') + 2);
+            client->cUrl = headerLine.substring(4, headerLine.indexOf(' ', 4));
+        } else if(headerLine.indexOf(':')) {
+            String headerName = headerLine.substring(0, headerLine.indexOf(':'));
+            String headerValue = headerLine.substring(headerLine.indexOf(':') + 2);

            if(headerName.equalsIgnoreCase("Connection")) {
                if(headerValue.indexOf("Upgrade") >= 0) {
@ -606,17 +492,11 @@ void WebSocketsServer::handleHeader(WSclient_t * client, String * headerLine) {
                client->cProtocol = headerValue;
            } else if(headerName.equalsIgnoreCase("Sec-WebSocket-Extensions")) {
                client->cExtensions = headerValue;
-            } else if(headerName.equalsIgnoreCase("Authorization")) {
-                client->base64Authorization = headerValue;
            }
        } else {
-            DEBUG_WEBSOCKETS("[WS-Client][handleHeader] Header error (%s)\n", headerLine->c_str());
+            DEBUG_WEBSOCKETS("[WS-Client][handleHeader] Header error (%s)\n", headerLine.c_str());
        }

-        (*headerLine) = "";
-#if (WEBSOCKETS_NETWORK_TYPE == NETWORK_ESP8266_ASYNC)
-        client->tcp->readStringUntil('\n', &(client->cHttpLine), std::bind(&WebSocketsServer::handleHeader, this, client, &(client->cHttpLine)));
-#endif
    } else {
        DEBUG_WEBSOCKETS("[WS-Server][%d][handleHeader] Header read fin.\n", client->num);

@ -627,7 +507,6 @@ void WebSocketsServer::handleHeader(WSclient_t * client, String * headerLine) {
        DEBUG_WEBSOCKETS("[WS-Server][%d][handleHeader]  - cProtocol: %s\n", client->num, client->cProtocol.c_str());
        DEBUG_WEBSOCKETS("[WS-Server][%d][handleHeader]  - cExtensions: %s\n", client->num, client->cExtensions.c_str());
        DEBUG_WEBSOCKETS("[WS-Server][%d][handleHeader]  - cVersion: %d\n", client->num, client->cVersion);
-        DEBUG_WEBSOCKETS("[WS-Server][%d][handleHeader]  - base64Authorization: %s\n", client->num, client->base64Authorization);

        bool ok = (client->cIsUpgrade && client->cIsWebsocket);

@ -643,23 +522,9 @@ void WebSocketsServer::handleHeader(WSclient_t * client, String * headerLine) {
            }
        }

-        if(_base64Authorization.length() > 0) {
-            if(client->base64Authorization.length() > 0) {
-                String auth = "Basic ";
-                auth += _base64Authorization;
-                if(auth != client->base64Authorization) {
-                    DEBUG_WEBSOCKETS("[WS-Server][%d][handleHeader] HTTP Authorization failed!\n", client->num);
-                    handleAuthorizationFailed(client);
-                    return;
-                }
-            } else {
-                ok = false;
-            }
-        }
-
        if(ok) {

-            DEBUG_WEBSOCKETS("[WS-Server][%d][handleHeader] Websocket connection incoming.\n", client->num);
+            DEBUG_WEBSOCKETS("[WS-Server][%d][handleHeader] Websocket connection incomming.\n", client->num);

            // generate Sec-WebSocket-Accept key
            String sKey = acceptKey(client->cKey);
@ -675,28 +540,16 @@ void WebSocketsServer::handleHeader(WSclient_t * client, String * headerLine) {
                    "Sec-WebSocket-Version: 13\r\n"
                    "Sec-WebSocket-Accept: ");
            client->tcp->write(sKey.c_str(), sKey.length());
-
-            if(_origin.length() > 0) {
-                String origin = "\r\nAccess-Control-Allow-Origin: ";
-                origin += _origin;
-                origin += "\r\n";
-                client->tcp->write(origin.c_str(), origin.length());
-            }
+            client->tcp->write("\r\n");

            if(client->cProtocol.length() > 0) {
-                String protocol = "\r\nSec-WebSocket-Protocol: ";
-                protocol += _protocol;
-                protocol += "\r\n";
-                client->tcp->write(protocol.c_str(), protocol.length());
-            } else {
-                client->tcp->write("\r\n");
+                // TODO add api to set Protocol of Server
+                client->tcp->write("Sec-WebSocket-Protocol: arduino\r\n");
            }

            // header end
            client->tcp->write("\r\n");

-            headerDone(client);
-
            // send ping
            WebSockets::sendFrame(client, WSop_ping);

--- a/src/WebSocketsServer.h
+++ b/src/WebSocketsServer.h
@ -36,60 +36,44 @@
 class WebSocketsServer: private WebSockets {
 public:

-#ifdef __AVR__
        typedef void (*WebSocketServerEvent)(uint8_t num, WStype_t type, uint8_t * payload, size_t length);
-#else
-        typedef std::function<void (uint8_t num, WStype_t type, uint8_t * payload, size_t length)> WebSocketServerEvent;
-#endif

-        WebSocketsServer(uint16_t port, String origin = "", String protocol = "arduino");
+        WebSocketsServer(uint16_t port);
        ~WebSocketsServer(void);

        void begin(void);
-
-#if (WEBSOCKETS_NETWORK_TYPE != NETWORK_ESP8266_ASYNC)
        void loop(void);
-#else
-        // Async interface not need a loop call
-        void loop(void) __attribute__ ((deprecated)) {}
-#endif

        void onEvent(WebSocketServerEvent cbEvent);


-        bool sendTXT(uint8_t num, uint8_t * payload, size_t length = 0, bool headerToPayload = false);
-        bool sendTXT(uint8_t num, const uint8_t * payload, size_t length = 0);
-        bool sendTXT(uint8_t num, char * payload, size_t length = 0, bool headerToPayload = false);
-        bool sendTXT(uint8_t num, const char * payload, size_t length = 0);
-        bool sendTXT(uint8_t num, String & payload);
+        void sendTXT(uint8_t num, uint8_t * payload, size_t length = 0, bool headerToPayload = false);
+        void sendTXT(uint8_t num, const uint8_t * payload, size_t length = 0);
+        void sendTXT(uint8_t num, char * payload, size_t length = 0, bool headerToPayload = false);
+        void sendTXT(uint8_t num, const char * payload, size_t length = 0);
+        void sendTXT(uint8_t num, String payload);

-        bool broadcastTXT(uint8_t * payload, size_t length = 0, bool headerToPayload = false);
-        bool broadcastTXT(const uint8_t * payload, size_t length = 0);
-        bool broadcastTXT(char * payload, size_t length = 0, bool headerToPayload = false);
-        bool broadcastTXT(const char * payload, size_t length = 0);
-        bool broadcastTXT(String & payload);
+        void broadcastTXT(uint8_t * payload, size_t length = 0, bool headerToPayload = false);
+        void broadcastTXT(const uint8_t * payload, size_t length = 0);
+        void broadcastTXT(char * payload, size_t length = 0, bool headerToPayload = false);
+        void broadcastTXT(const char * payload, size_t length = 0);
+        void broadcastTXT(String payload);

-        bool sendBIN(uint8_t num, uint8_t * payload, size_t length, bool headerToPayload = false);
-        bool sendBIN(uint8_t num, const uint8_t * payload, size_t length);
+        void sendBIN(uint8_t num, uint8_t * payload, size_t length, bool headerToPayload = false);
+        void sendBIN(uint8_t num, const uint8_t * payload, size_t length);

-        bool broadcastBIN(uint8_t * payload, size_t length, bool headerToPayload = false);
-        bool broadcastBIN(const uint8_t * payload, size_t length);
+        void broadcastBIN(uint8_t * payload, size_t length, bool headerToPayload = false);
+        void broadcastBIN(const uint8_t * payload, size_t length);

        void disconnect(void);
        void disconnect(uint8_t num);

-        void setAuthorization(const char * user, const char * password);
-        void setAuthorization(const char * auth);
-
-#if (WEBSOCKETS_NETWORK_TYPE == NETWORK_ESP8266) || (WEBSOCKETS_NETWORK_TYPE == NETWORK_ESP8266_ASYNC)
+#if (WEBSOCKETS_NETWORK_TYPE == NETWORK_ESP8266)
        IPAddress remoteIP(uint8_t num);
 #endif

 protected:
        uint16_t _port;
-        String _origin;
-        String _protocol;
-        String _base64Authorization; ///< Base64 encoded Auth request

        WEBSOCKETS_NETWORK_SERVER_CLASS * _server;

@ -97,24 +81,19 @@ protected:

        WebSocketServerEvent _cbEvent;

-        bool newClient(WEBSOCKETS_NETWORK_CLASS * TCPclient);
-
        void messageRecived(WSclient_t * client, WSopcode_t opcode, uint8_t * payload, size_t length);

        void clientDisconnect(WSclient_t * client);
        bool clientIsConnected(WSclient_t * client);

-#if (WEBSOCKETS_NETWORK_TYPE != NETWORK_ESP8266_ASYNC)
        void handleNewClients(void);
        void handleClientData(void);
-#endif
-
-        void handleHeader(WSclient_t * client, String * headerLine);

+        void handleHeader(WSclient_t * client);

        /**
-         * called if a non Websocket connection is coming in.
-         * Note: can be override
+         * called if a non Websocket connection is comming in.
+         * Note: can be overrided
         * @param client WSclient_t *  ptr to the client struct
         */
        virtual void handleNonWebsocketConnection(WSclient_t * client) {
@ -130,25 +109,6 @@ protected:
            clientDisconnect(client);
        }

-        /**
-         * called if a non Authorization connection is coming in.
-         * Note: can be override
-         * @param client WSclient_t *  ptr to the client struct
-         */
-        virtual void handleAuthorizationFailed(WSclient_t *client) {
-
-            client->tcp->write("HTTP/1.1 401 Unauthorized\r\n"
-                    "Server: arduino-WebSocket-Server\r\n"
-                    "Content-Type: text/plain\r\n"
-                    "Content-Length: 45\r\n"
-                    "Connection: close\r\n"
-                    "Sec-WebSocket-Version: 13\r\n"
-                    "WWW-Authenticate: Basic realm=\"WebSocket Server\""
-                    "\r\n"
-                    "This Websocket server requires Authorization!");
-            clientDisconnect(client);
-        }
-
        /**
         * called for sending a Event to the app
         * @param num uint8_t
--- a/tests/webSocket.html
+++ b/tests/webSocket.html
@ -8,11 +8,10 @@ connection.onopen = function () {
 	connection.send('Message from Browser to ESP8266 yay its Working!! ' + new Date()); 
 	connection.send('ping');
 	
-/*	setInterval(function() {
+	setInterval(function() {
 		connection.send('Time: ' + new Date()); 
 	}, 20);
-*/
-connection.send('Time: ' + new Date()); 
+
 };

 connection.onerror = function (error) {
@ -21,7 +20,6 @@ connection.onerror = function (error) {

 connection.onmessage = function (e) {
 	console.log('Server: ', e.data);
-	connection.send('Time: ' + new Date()); 
 };

 function sendRGB() {
--- a/tests/webSocketServer/index.js
+++ b/tests/webSocketServer/index.js
@ -41,11 +41,11 @@ wsServer.on('request', function(request) {
 	connection.on('message', function(message) {
        if (message.type === 'utf8') {
            console.log('Received Message: ' + message.utf8Data);
-           // connection.sendUTF(message.utf8Data);
+            connection.sendUTF(message.utf8Data);
        }
        else if (message.type === 'binary') {
            console.log('Received Binary Message of ' + message.binaryData.length + ' bytes');
-           //connection.sendBytes(message.binaryData);
+            connection.sendBytes(message.binaryData);
        }
    });
    
--- a/travis/common.sh
+++ b/travis/common.sh
@ -0,0 +1,53 @@
+#!/bin/bash
+
+function build_sketches()
+{
+    local arduino=$1
+    local srcpath=$2
+    local platform=$3
+    local sketches=$(find $srcpath -name *.ino)
+    for sketch in $sketches; do
+        local sketchdir=$(dirname $sketch)
+        if [[ -f "$sketchdir/.$platform.skip" ]]; then
+            echo -e "\n\n ------------ Skipping $sketch ------------ \n\n";
+            continue
+        fi
+        echo -e "\n\n ------------ Building $sketch ------------ \n\n";
+        $arduino --verify $sketch;
+        local result=$?
+        if [ $result -ne 0 ]; then
+            echo "Build failed ($sketch) build verbose..."
+            $arduino --verify --verbose --preserve-temp-files $sketch
+            result=$?
+        fi
+        if [ $result -ne 0 ]; then
+            echo "Build failed ($1) $sketch"
+            return $result
+        fi
+    done
+}
+
+
+function get_core()
+{
+    echo Setup core for $1
+
+    cd $HOME/arduino_ide/hardware
+
+    if [ "$1" = "esp8266" ] ; then
+        mkdir esp8266com
+        cd esp8266com
+        git clone https://github.com/esp8266/Arduino.git esp8266
+        cd esp8266/tools
+        python get.py
+    fi
+
+    if [ "$1" = "esp32" ] ; then
+        mkdir espressif
+        cd espressif
+        git clone https://github.com/espressif/arduino-esp32.git esp32
+        cd esp32/tools
+        python get.py
+    fi
+
+}
Author	SHA1	Message	Date
Markus	11273d9f69	Merge pull request #378 from Niklas04/patch-1 Update WebSocketsClient.cpp	2019-05-30 16:48:05 +02:00
Niklas04	82e3c57006	Update WebSocketsClient.cpp fix a issue relating to a comparison that fails due to capitalisation of the word	2018-10-09 21:28:02 +02:00
Links	3f5c7e1c46	add travis build test	2018-05-19 19:26:12 +02:00
Markus	7c5113fe2d	fix #154 - _fingerprint not declared in this scope fix #154 - _fingerprint not declared in this scope	2016-12-27 14:16:12 +01:00