add function to send WS ping

sendPing(); #130
fix WebSocketClientSocketIO example
2025-06-25 23:11:36 +02:00 · 2016-10-22 19:47:44 +02:00 · 2016-10-22 20:36:36 +02:00 · 2016-09-28 18:28:28 +02:00 · 2016-09-27 11:25:56 +02:00 · 2016-09-11 17:13:57 +02:00
16 changed files with 1444 additions and 378 deletions
--- a/README.md
+++ b/README.md
@ -18,18 +18,40 @@ a WebSocket Server and Client for Arduino based on RFC6455.
 - max input length is limited to the ram size and the ```WEBSOCKETS_MAX_DATA_SIZE``` define
 - max output length has no limit (the hardware is the limit)
 - Client send big frames with mask 0x00000000 (on AVR all frames)
-
+ 
+ ##### Limitations for Async #####
+ - Functions called from within the context of the websocket event might not honor `yield()` and/or `delay()`.  See [this issue](https://github.com/Links2004/arduinoWebSockets/issues/58#issuecomment-192376395) for more info and a potential workaround.
+ - wss / SSL is not possible.
+ 
 ##### Supported Hardware #####
 - ESP8266 [Arduino for ESP8266](https://github.com/Links2004/Arduino)
- - ATmega328 with Ethernet Shield (alpha)
- - ATmega328 with enc28j60 (alpha)
- - ATmega2560 with Ethernet Shield (alpha)
- - ATmega2560 with enc28j60 (alpha)
+ - 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++.
 
 ### wss / SSL ###
 supported for:
 - wss client on the ESP8266
+ - wss / SSL is not natively supported in WebSocketsServer however it is possible to achieve secure websockets
+   by running the device behind an SSL proxy. See [Nginx](examples/Nginx/esp8266.ssl.reverse.proxy.conf) for a
+   sample Nginx server configuration file to enable this. 
 
+### 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.
+
 ### Issues ###
 Submit issues to: https://github.com/Links2004/arduinoWebSockets/issues

--- a/examples/Nginx/esp8266.ssl.reverse.proxy.conf
+++ b/examples/Nginx/esp8266.ssl.reverse.proxy.conf
@ -0,0 +1,83 @@
+# ESP8266 nginx SSL reverse proxy configuration file (tested and working on nginx v1.10.0)
+
+# proxy cache location
+proxy_cache_path /opt/etc/nginx/cache levels=1:2 keys_zone=ESP8266_cache:10m max_size=10g inactive=5m use_temp_path=off;
+
+# webserver proxy
+server {
+
+    # general server parameters
+    listen                      50080;
+    server_name                 myDomain.net;
+    access_log                  /opt/var/log/nginx/myDomain.net.access.log;       
+
+    # SSL configuration
+    ssl                         on;
+    ssl_certificate             /usr/builtin/etc/certificate/lets-encrypt/myDomain.net/fullchain.pem;
+    ssl_certificate_key         /usr/builtin/etc/certificate/lets-encrypt/myDomain.net/privkey.pem;
+    ssl_session_cache           builtin:1000  shared:SSL:10m;
+    ssl_protocols               TLSv1 TLSv1.1 TLSv1.2;
+    ssl_ciphers                 HIGH:!aNULL:!eNULL:!EXPORT:!CAMELLIA:!DES:!MD5:!PSK:!RC4;
+    ssl_prefer_server_ciphers   on;
+    
+    location / {
+
+      # proxy caching configuration
+      proxy_cache             ESP8266_cache;
+      proxy_cache_revalidate  on;
+      proxy_cache_min_uses    1;
+      proxy_cache_use_stale   off;
+      proxy_cache_lock        on;
+      # proxy_cache_bypass      $http_cache_control;      
+      # include the sessionId cookie value as part of the cache key - keeps the cache per user
+      # proxy_cache_key         $proxy_host$request_uri$cookie_sessionId;
+
+      # header pass through configuration
+      proxy_set_header        Host $host;      
+      proxy_set_header        X-Forwarded-For $proxy_add_x_forwarded_for;
+      proxy_set_header        X-Forwarded-Proto $scheme;      
+
+      # ESP8266 custom headers which identify to the device that it's running through an SSL proxy     
+      proxy_set_header        X-SSL On;
+      proxy_set_header        X-SSL-WebserverPort 50080;
+      proxy_set_header        X-SSL-WebsocketPort 50081;
+
+      # extra debug headers      
+      add_header              X-Proxy-Cache $upstream_cache_status;
+      add_header              X-Forwarded-For $proxy_add_x_forwarded_for;
+
+      # actual proxying configuration
+      proxy_ssl_session_reuse on;
+      # target the IP address of the device with proxy_pass
+      proxy_pass              http://192.168.0.20;
+      proxy_read_timeout      90;
+    }
+ }
+
+# websocket proxy
+server {
+
+    # general server parameters
+    listen                      50081;
+    server_name                 myDomain.net;
+    access_log                  /opt/var/log/nginx/myDomain.net.wss.access.log;
+
+    # SSL configuration
+    ssl                         on;
+    ssl_certificate             /usr/builtin/etc/certificate/lets-encrypt/myDomain.net/fullchain.pem;
+    ssl_certificate_key         /usr/builtin/etc/certificate/lets-encrypt/myDomain.net/privkey.pem;
+    ssl_session_cache           builtin:1000  shared:SSL:10m;
+    ssl_protocols               TLSv1 TLSv1.1 TLSv1.2;
+    ssl_ciphers                 HIGH:!aNULL:!eNULL:!EXPORT:!CAMELLIA:!DES:!MD5:!PSK:!RC4;
+    ssl_prefer_server_ciphers   on;
+    
+    location / {     
+
+      # websocket upgrade tunnel configuration
+      proxy_pass                    http://192.168.0.20:81;
+      proxy_http_version            1.1;
+      proxy_set_header Upgrade      $http_upgrade;
+      proxy_set_header Connection   "Upgrade";
+      proxy_read_timeout            86400;
+    }
+ }
--- a/examples/WebSocketClient/WebSocketClient.ino
+++ b/examples/WebSocketClient/WebSocketClient.ino
@ -77,6 +77,7 @@ void setup() {
    }

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

 }
--- a/examples/WebSocketClientSSL/WebSocketClientSSL.ino
+++ b/examples/WebSocketClientSSL/WebSocketClientSSL.ino
@ -22,7 +22,7 @@ WebSocketsClient webSocket;

 #define USE_SERIAL Serial1

-void webSocketEvent(WStype_t type, uint8_t * payload, size_t lenght) {
+void webSocketEvent(WStype_t type, uint8_t * payload, size_t length) {


    switch(type) {
@ -44,11 +44,11 @@ void webSocketEvent(WStype_t type, uint8_t * payload, size_t lenght) {
 			// webSocket.sendTXT("message here");
            break;
        case WStype_BIN:
-            USE_SERIAL.printf("[WSc] get binary lenght: %u\n", lenght);
-            hexdump(payload, lenght);
+            USE_SERIAL.printf("[WSc] get binary length: %u\n", length);
+            hexdump(payload, length);

            // send data to server
-            // webSocket.sendBIN(payload, lenght);
+            // webSocket.sendBIN(payload, length);
            break;
    }

--- a/examples/WebSocketClientSocketIO/WebSocketClientSocketIO.ino
+++ b/examples/WebSocketClientSocketIO/WebSocketClientSocketIO.ino
@ -0,0 +1,113 @@
+/*
+ * WebSocketClientSocketIO.ino
+ *
+ *  Created on: 06.06.2016
+ *
+ */
+
+#include <Arduino.h>
+
+#include <ESP8266WiFi.h>
+#include <ESP8266WiFiMulti.h>
+
+#include <WebSocketsClient.h>
+
+#include <Hash.h>
+
+ESP8266WiFiMulti WiFiMulti;
+WebSocketsClient webSocket;
+
+
+#define USE_SERIAL Serial1
+
+#define MESSAGE_INTERVAL 30000
+#define HEARTBEAT_INTERVAL 25000
+
+uint64_t messageTimestamp = 0;
+uint64_t heartbeatTimestamp = 0;
+bool isConnected = false;
+
+void webSocketEvent(WStype_t type, uint8_t * payload, size_t lenght) {
+
+
+    switch(type) {
+        case WStype_DISCONNECTED:
+            USE_SERIAL.printf("[WSc] Disconnected!\n");
+            isConnected = false;
+            break;
+        case WStype_CONNECTED:
+            {
+                USE_SERIAL.printf("[WSc] Connected to url: %s\n",  payload);
+                isConnected = true;
+
+			    // send message to server when Connected
+                // socket.io upgrade confirmation message (required)
+				webSocket.sendTXT("5");
+            }
+            break;
+        case WStype_TEXT:
+            USE_SERIAL.printf("[WSc] get text: %s\n", payload);
+
+			// send message to server
+			// webSocket.sendTXT("message here");
+            break;
+        case WStype_BIN:
+            USE_SERIAL.printf("[WSc] get binary lenght: %u\n", lenght);
+            hexdump(payload, lenght);
+
+            // send data to server
+            // webSocket.sendBIN(payload, lenght);
+            break;
+    }
+
+}
+
+void setup() {
+    // USE_SERIAL.begin(921600);
+    USE_SERIAL.begin(115200);
+
+    //Serial.setDebugOutput(true);
+    USE_SERIAL.setDebugOutput(true);
+
+    USE_SERIAL.println();
+    USE_SERIAL.println();
+    USE_SERIAL.println();
+
+      for(uint8_t t = 4; t > 0; t--) {
+          USE_SERIAL.printf("[SETUP] BOOT WAIT %d...\n", t);
+          USE_SERIAL.flush();
+          delay(1000);
+      }
+
+    WiFiMulti.addAP("SSID", "passpasspass");
+
+    //WiFi.disconnect();
+    while(WiFiMulti.run() != WL_CONNECTED) {
+        delay(100);
+    }
+
+    webSocket.beginSocketIO("192.168.0.123", 81);
+    //webSocket.setAuthorization("user", "Password"); // HTTP Basic Authorization
+    webSocket.onEvent(webSocketEvent);
+
+}
+
+void loop() {
+    webSocket.loop();
+
+    if(isConnected) {
+
+        uint64_t now = millis();
+
+        if(now - messageTimestamp > MESSAGE_INTERVAL) {
+            messageTimestamp = now;
+            // example socket.io message with type "messageType" and JSON payload
+            webSocket.sendTXT("42[\"messageType\",{\"greeting\":\"hello\"}]");
+        }
+        if((now - heartbeatTimestamp) > HEARTBEAT_INTERVAL) {
+            heartbeatTimestamp = now;
+            // socket.io heartbeat message
+            webSocket.sendTXT("2");
+        }
+    }
+}
--- a/examples/WebSocketServer/WebSocketServerHttpHeaderValidation.ino
+++ b/examples/WebSocketServer/WebSocketServerHttpHeaderValidation.ino
@ -0,0 +1,86 @@
+/*
+ * WebSocketServerHttpHeaderValidation.ino
+ *
+ *  Created on: 08.06.2016
+ *
+ */
+
+#include <Arduino.h>
+
+#include <ESP8266WiFi.h>
+#include <ESP8266WiFiMulti.h>
+#include <WebSocketsServer.h>
+#include <Hash.h>
+
+ESP8266WiFiMulti WiFiMulti;
+
+WebSocketsServer webSocket = WebSocketsServer(81);
+
+#define USE_SERIAL Serial1
+
+const unsigned long int validSessionId = 12345; //some arbitrary value to act as a valid sessionId
+
+/*
+ * Returns a bool value as an indicator to describe whether a user is allowed to initiate a websocket upgrade
+ * based on the value of a cookie. This function expects the rawCookieHeaderValue to look like this "sessionId=<someSessionIdNumberValue>|"
+ */
+bool isCookieValid(String rawCookieHeaderValue) {
+
+	if (rawCookieHeaderValue.indexOf("sessionId") != -1) {
+		String sessionIdStr = rawCookieHeaderValue.substring(rawCookieHeaderValue.indexOf("sessionId=") + 10, rawCookieHeaderValue.indexOf("|"));
+		unsigned long int sessionId = strtoul(sessionIdStr.c_str(), NULL, 10);
+		return sessionId == validSessionId;
+	}
+	return false;
+}
+
+/*
+ * The WebSocketServerHttpHeaderValFunc delegate passed to webSocket.onValidateHttpHeader
+ */
+bool validateHttpHeader(String headerName, String headerValue) {
+
+	//assume a true response for any headers not handled by this validator
+	bool valid = true;
+
+	if(headerName.equalsIgnoreCase("Cookie")) {
+		//if the header passed is the Cookie header, validate it according to the rules in 'isCookieValid' function
+		valid = isCookieValid(headerValue);
+	}
+
+	return valid;
+}
+
+void setup() {
+    // USE_SERIAL.begin(921600);
+    USE_SERIAL.begin(115200);
+
+    //Serial.setDebugOutput(true);
+    USE_SERIAL.setDebugOutput(true);
+
+    USE_SERIAL.println();
+    USE_SERIAL.println();
+    USE_SERIAL.println();
+
+    for(uint8_t t = 4; t > 0; t--) {
+        USE_SERIAL.printf("[SETUP] BOOT WAIT %d...\n", t);
+        USE_SERIAL.flush();
+        delay(1000);
+    }
+
+    WiFiMulti.addAP("SSID", "passpasspass");
+
+    while(WiFiMulti.run() != WL_CONNECTED) {
+        delay(100);
+    }
+
+    //connecting clients must supply a valid session cookie at websocket upgrade handshake negotiation time
+    const char * headerkeys[] = { "Cookie" };
+    size_t headerKeyCount = sizeof(headerkeys) / sizeof(char*);
+    webSocket.onValidateHttpHeader(validateHttpHeader, headerkeys, headerKeyCount);
+    webSocket.begin();
+}
+
+void loop() {
+    webSocket.loop();
+}
+
--- a/library.json
+++ b/library.json
@ -1,19 +1,28 @@
 {
-  "name": "WebSockets",
-  "keywords": "wifi, http, web, server, client, websocket",
-  "description": "WebSocket Server and Client for Arduino based on RFC6455",
-  "repository":
-  {
-    "type": "git",
-    "url": "https://github.com/Links2004/arduinoWebSockets.git"
-  },
-  "exclude": "tests",
-  "frameworks": "arduino",
-  "platforms": "*",
-  "authors":
-  {
-    "name": "Markus Sattler",
-    "url": "https://github.com/Links2004",
-    "maintainer": true
-  }
+    "name": "WebSockets",
+    "description": "WebSocket Server and Client for Arduino based on RFC6455",
+    "keywords": "wifi, http, web, server, client, websocket",
+    "authors": [
+        {
+            "name": "Markus Sattler",
+            "url": "https://github.com/Links2004",
+            "maintainer": true
+        }
+    ],
+    "repository": {
+        "type": "git",
+        "url": "https://github.com/Links2004/arduinoWebSockets.git"
+    },
+    "version": "2.0.5",
+    "license": "LGPL-2.1",
+    "export": {
+        "exclude": [
+            "tests"
+        ]
+    },
+    "frameworks": "arduino",
+    "platforms": "*",
+    "examples": [
+        "examples/*/*.ino"
+    ]
 }
--- a/library.properties
+++ b/library.properties
@ -1,9 +1,9 @@
 name=WebSockets
-version=1.3
+version=2.0.5
 author=Markus Sattler
 maintainer=Markus Sattler 
 sentence=WebSockets for Arduino (Server + Client)
-paragraph=
+paragraph=use 2.x.x for ESP and 1.3 for AVR
 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,8 +46,6 @@ extern "C" {

 #endif

-#define WEBSOCKETS_MAX_HEADER_SIZE  (14)
-
 /**
 *
 * @param client WSclient_t *  ptr to the client struct
@ -79,17 +77,18 @@ 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
 */
-void WebSockets::sendFrame(WSclient_t * client, WSopcode_t opcode, uint8_t * payload, size_t length, bool mask, bool fin, bool headerToPayload) {
+bool 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;
+        return false;
    }

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

    DEBUG_WEBSOCKETS("[WS][%d][sendFrame] ------- send massage frame -------\n", client->num);
@ -106,6 +105,7 @@ void 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,7 +120,6 @@ void 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)
@ -161,22 +160,35 @@ void 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) {
@ -185,7 +197,8 @@ void 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;
@ -201,10 +214,14 @@ void 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++;
        }
    }

@ -216,14 +233,20 @@ void 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
-        client->tcp->write(&payloadPtr[(WEBSOCKETS_MAX_HEADER_SIZE - headerSize)], (length + headerSize));
+        if(client->tcp->write(&payloadPtr[(WEBSOCKETS_MAX_HEADER_SIZE - headerSize)], (length + headerSize)) != (length + headerSize)) {
+            ret = false;
+        }
    } else {
        // send header
-        client->tcp->write(&buffer[0], headerSize);
+        if(client->tcp->write(&buffer[0], headerSize) != headerSize) {
+            ret = false;
+        }

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

@ -235,6 +258,21 @@ void 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
 }

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

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

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

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

+    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;

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

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

    // split first 2 bytes in the data
-    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->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++;

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

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

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

-    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);
+    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);

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

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

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

        if(!payload) {
-            DEBUG_WEBSOCKETS("[WS][%d][handleWebsocket] to less memory to handle payload %d!\n", client->num, payloadLen);
+            DEBUG_WEBSOCKETS("[WS][%d][handleWebsocket] to less memory to handle payload %d!\n", client->num, header->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);
+    }
+}

-        if(!readWait(client, payload, payloadLen)) {
-            DEBUG_WEBSOCKETS("[WS][%d][handleWebsocket] missing data!\n", client->num);
-            free(payload);
-            clientDisconnect(client, 1002);
-            return;
-        }
+void WebSockets::handleWebsocketPayloadCb(WSclient_t * client, bool ok, uint8_t * payload) {

-        payload[payloadLen] = 0x00;
+    WSMessageHeader_t * header = &client->cWsHeaderDecode;
+    if(ok) {
+        if(header->payloadLen > 0) {
+            payload[header->payloadLen] = 0x00;

-        if(mask) {
-            //decode XOR
-            for(size_t i = 0; i < payloadLen; i++) {
-                payload[i] = (payload[i] ^ maskKey[i % 4]);
+            if(header->mask) {
+                //decode XOR
+                for(size_t i = 0; i < header->payloadLen; i++) {
+                    payload[i] = (payload[i] ^ header->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:
-            {
+        switch(header->opCode) {
+            case WSop_text:
+                DEBUG_WEBSOCKETS("[WS][%d][handleWebsocket] text: %s\n", client->num, payload);
+                // no break here!
+            case WSop_binary:
+                messageReceived(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: {
                uint16_t reasonCode = 1000;
-                if(payloadLen >= 2) {
+                if(header->payloadLen >= 2) {
                    reasonCode = payload[0] << 8 | payload[1];
                }

                DEBUG_WEBSOCKETS("[WS][%d][handleWebsocket] get ask for close. Code: %d", client->num, reasonCode);
-                if(payloadLen > 2) {
-                    DEBUG_WEBSOCKETS(" (%s)\n", (payload+2));
+                if(header->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;
-    }
+                break;
+            case WSop_continuation:
+                // continuation is not supported
+                clientDisconnect(client, 1003);
+                break;
+            default:
+                clientDisconnect(client, 1002);
+                break;
+        }

-    if(payload) {
+        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);
    }
-
 }

 /**
@ -392,7 +482,7 @@ void WebSockets::handleWebsocket(WSclient_t * client) {
 * @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]);
@ -417,7 +507,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;
@ -439,28 +529,49 @@ String WebSockets::base64_encode(uint8_t * data, size_t length) {
 * @param n size_t byte count
 * @return true if ok
 */
-bool WebSockets::readWait(WSclient_t * client, uint8_t *out, size_t n) {
+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
    unsigned long t = millis();
    size_t len;
-
+    DEBUG_WEBSOCKETS("[readCb] n: %d t: %d\n", n, t);
    while(n > 0) {
-        if(!client->tcp) {
-            DEBUG_WEBSOCKETS("[readWait] tcp is null!\n");
+        if(client->tcp == NULL) {
+            DEBUG_WEBSOCKETS("[readCb] tcp is null!\n");
+            if(cb) {
+                cb(client, false);
+            }
            return false;
        }

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

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

        if(!client->tcp->available()) {
-#ifdef ESP8266
+#if (WEBSOCKETS_NETWORK_TYPE == NETWORK_ESP8266)
            delay(0);
 #endif
            continue;
@ -475,9 +586,13 @@ bool WebSockets::readWait(WSclient_t * client, uint8_t *out, size_t n) {
        } else {
            //DEBUG_WEBSOCKETS("Receive %d left %d!\n", len, n);
        }
-#ifdef ESP8266
+#if (WEBSOCKETS_NETWORK_TYPE == NETWORK_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(...) Serial1.printf( __VA_ARGS__ )
+//#define DEBUG_WEBSOCKETS(...) os_printf( __VA_ARGS__ )

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

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

-#define NETWORK_ESP8266     (1)
-#define NETWORK_W5100       (2)
-#define NETWORK_ENC28J60    (3)
+#define NETWORK_ESP8266_ASYNC   (0)
+#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)

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

+#if (WEBSOCKETS_NETWORK_TYPE == NETWORK_ESP8266_ASYNC)

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

-#ifndef 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)
 #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

@ -110,6 +139,21 @@ 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

@ -117,6 +161,8 @@ typedef struct {

        WEBSOCKETS_NETWORK_CLASS * tcp;

+        bool isSocketIO;    ///< client for socket.io server
+
 #if (WEBSOCKETS_NETWORK_TYPE == NETWORK_ESP8266)
        bool isSSL;             ///< run in ssl mode
        WiFiClientSecure * ssl;
@ -128,32 +174,61 @@ typedef struct {
        bool cIsUpgrade;    ///< Connection == Upgrade
        bool cIsWebsocket;  ///< Upgrade == websocket

+        String cSessionId;  ///< client Set-Cookie (session id)
        String cKey;        ///< client Sec-WebSocket-Key
        String cAccept;     ///< client Sec-WebSocket-Accept
        String cProtocol;   ///< client Sec-WebSocket-Protocol
        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
+        String plainAuthorization; ///< Base64 encoded Auth request
+
+        bool cHttpHeadersValid; ///< non-websocket http header validity indicator
+        size_t cMandatoryHeadersCount; ///< non-websocket mandatory http headers present count
+
+#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);
+        virtual void messageReceived(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);
-        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);
+        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 headerDone(WSclient_t * client);

        void handleWebsocket(WSclient_t * client);

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

-        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,6 +25,7 @@
 #include "WebSockets.h"
 #include "WebSocketsClient.h"

+
 WebSocketsClient::WebSocketsClient() {
    _cbEvent = NULL;
    _client.num = 0;
@ -37,10 +38,12 @@ WebSocketsClient::~WebSocketsClient() {
 /**
 * calles to init the Websockets server
 */
-void WebSocketsClient::begin(const char *host, uint16_t port, const char * url) {
+void WebSocketsClient::begin(const char *host, uint16_t port, const char * url, const char * protocol) {
    _host = host;
    _port = port;
+#if (WEBSOCKETS_NETWORK_TYPE == NETWORK_ESP8266)
    _fingerprint = "";
+#endif

    _client.num = 0;
    _client.status = WSC_NOT_CONNECTED;
@ -55,9 +58,11 @@ void WebSocketsClient::begin(const char *host, uint16_t port, const char * url)
    _client.cIsWebsocket = true;
    _client.cKey = "";
    _client.cAccept = "";
-    _client.cProtocol = "";
+    _client.cProtocol = protocol;
    _client.cExtensions = "";
    _client.cVersion = 0;
+    _client.base64Authorization = "";
+    _client.plainAuthorization = "";

 #ifdef ESP8266
    randomSeed(RANDOM_REG32);
@ -65,24 +70,37 @@ 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) {
-    begin(host.c_str(), port, url.c_str());
+void WebSocketsClient::begin(String host, uint16_t port, String url, String protocol) {
+    begin(host.c_str(), port, url.c_str(), protocol.c_str());
 }

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

-void WebSocketsClient::beginSSL(String host, uint16_t port, String url, String fingerprint) {
-    beginSSL(host.c_str(), port, url.c_str(), fingerprint.c_str());
+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());
 }
 #endif

+void WebSocketsClient::beginSocketIO(const char *host, uint16_t port, const char * url, const char * protocol) {
+    begin(host, port, url, protocol);
+    _client.isSocketIO = true;
+}
+
+void WebSocketsClient::beginSocketIO(String host, uint16_t port, String url, String protocol) {
+    beginSocketIO(host.c_str(), port, url.c_str(), protocol.c_str());
+}
+
+#if (WEBSOCKETS_NETWORK_TYPE != NETWORK_ESP8266_ASYNC)
 /**
 * called in arduino loop
 */
@ -117,36 +135,16 @@ void WebSocketsClient::loop(void) {
        }

        if(_client.tcp->connect(_host.c_str(), _port)) {
-            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);
-
+            connectedCb();
        } else {
-            DEBUG_WEBSOCKETS("[WS-Client] connection to %s:%u Faild\n", _host.c_str(), _port);
-            delay(10); //some litle delay to not flood the server
+            connectFailedCb();
+            delay(10); //some little delay to not flood the server
        }
    } else {
        handleClientData();
    }
 }
+#endif

 /**
 * set callback function
@ -162,30 +160,32 @@ 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
 */
-void WebSocketsClient::sendTXT(uint8_t * payload, size_t length, bool headerToPayload) {
+bool WebSocketsClient::sendTXT(uint8_t * payload, size_t length, bool headerToPayload) {
    if(length == 0) {
        length = strlen((const char *) payload);
    }
    if(clientIsConnected(&_client)) {
-        sendFrame(&_client, WSop_text, payload, length, true, true, headerToPayload);
+        return sendFrame(&_client, WSop_text, payload, length, true, true, headerToPayload);
    }
+    return false;
 }

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

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

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

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

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

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

+/**
+ * sends a WS ping to Server
+ * @param payload uint8_t *
+ * @param length size_t
+ * @return true if ping is send out
+ */
+bool WebSocketsClient::sendPing(uint8_t * payload, size_t length) {
+    if(clientIsConnected(&_client)) {
+        return sendFrame(&_client, WSop_ping, payload, length);
+    }
+    return false;
+}
+
+bool WebSocketsClient::sendPing(String & payload) {
+    return sendPing((uint8_t *) payload.c_str(), payload.length());
+}
+
+
 /**
 * disconnect one client
 * @param num uint8_t client id
@ -215,6 +235,31 @@ 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;
+        _client.plainAuthorization = auth;
+    }
+}
+
 //#################################################################################
 //#################################################################################
 //#################################################################################
@ -226,7 +271,7 @@ void WebSocketsClient::disconnect(void) {
 * @param payload  uint8_t *
 * @param lenght size_t
 */
-void WebSocketsClient::messageRecived(WSclient_t * client, WSopcode_t opcode, uint8_t * payload, size_t lenght) {
+void WebSocketsClient::messageReceived(WSclient_t * client, WSopcode_t opcode, uint8_t * payload, size_t lenght) {
    WStype_t type = WStype_ERROR;

    switch(opcode) {
@ -248,12 +293,15 @@ 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;
@ -262,10 +310,17 @@ 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;
    }

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

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

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

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

 /**
 * send the WebSocket header to Server
@ -360,23 +419,54 @@ void WebSocketsClient::sendHeader(WSclient_t * client) {
    unsigned long start = micros();
 #endif

-    String handshake =  "GET " + client->cUrl + " HTTP/1.1\r\n"
-                        "Host: " + _host + "\r\n"
-                        "Upgrade: websocket\r\n"
-                        "Connection: Upgrade\r\n"
-                        "User-Agent: arduino-WebSocket-Client\r\n"
-                        "Sec-WebSocket-Version: 13\r\n"
-                        "Sec-WebSocket-Protocol: arduino\r\n"
-                        "Sec-WebSocket-Key: " + client->cKey + "\r\n";
+    String transport;
+    String handshake;
+    if(!client->isSocketIO || (client->isSocketIO && client->cSessionId.length() > 0)) {
+        if(client->isSocketIO) {
+            transport = "&transport=websocket&sid=" + client->cSessionId;
+        }
+        handshake = "GET " + client->cUrl + transport + " HTTP/1.1\r\n"
+                    "Host: " + _host + ":" + _port + "\r\n"
+                    "Connection: Upgrade\r\n"
+                    "Upgrade: websocket\r\n"
+                    "Origin: file://\r\n"
+                    "User-Agent: arduino-WebSocket-Client\r\n"
+                    "Sec-WebSocket-Version: 13\r\n"
+                    "Sec-WebSocket-Key: " + client->cKey + "\r\n";

-    if(client->cExtensions.length() > 0) {
-        handshake += "Sec-WebSocket-Extensions: " + client->cExtensions + "\r\n";
+        if(client->cProtocol.length() > 0) {
+           handshake += "Sec-WebSocket-Protocol: " + client->cProtocol + "\r\n";
+        }
+
+        if(client->cExtensions.length() > 0) {
+            handshake += "Sec-WebSocket-Extensions: " + client->cExtensions + "\r\n";
+        }
+
+    } else {
+        handshake = "GET " + client->cUrl + "&transport=polling HTTP/1.1\r\n"
+                    "Connection: keep-alive\r\n";
+    }
+
+    handshake +=    "Host: " + _host + ":" + _port + "\r\n"
+                    "Origin: file://\r\n"
+                    "User-Agent: arduino-WebSocket-Client\r\n";
+
+    if(client->base64Authorization.length() > 0) {
+        handshake += "Authorization: Basic " + client->base64Authorization + "\r\n";
+    }
+
+    if(client->plainAuthorization.length() > 0) {
+        handshake += "Authorization: " + client->plainAuthorization + "\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));

 }
@ -385,23 +475,22 @@ 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) {
+void WebSocketsClient::handleHeader(WSclient_t * client, String * headerLine) {

-    String headerLine = client->tcp->readStringUntil('\n');
-    headerLine.trim(); // remove \r
+    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")) {
@ -417,11 +506,18 @@ void WebSocketsClient::handleHeader(WSclient_t * client) {
                client->cExtensions = headerValue;
            } else if(headerName.equalsIgnoreCase("Sec-WebSocket-Version")) {
                client->cVersion = headerValue.toInt();
+            } else if(headerName.equalsIgnoreCase("Set-Cookie")) {
+                client->cSessionId = headerValue.substring(headerValue.indexOf('=') + 1);
            }
        } 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");
@ -437,6 +533,7 @@ void WebSocketsClient::handleHeader(WSclient_t * client) {
        DEBUG_WEBSOCKETS("[WS-Client][handleHeader]  - cProtocol: %s\n", client->cProtocol.c_str());
        DEBUG_WEBSOCKETS("[WS-Client][handleHeader]  - cExtensions: %s\n", client->cExtensions.c_str());
        DEBUG_WEBSOCKETS("[WS-Client][handleHeader]  - cVersion: %d\n", client->cVersion);
+        DEBUG_WEBSOCKETS("[WS-Client][handleHeader]  - cSessionId: %s\n", client->cSessionId.c_str());

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

@ -445,6 +542,10 @@ void WebSocketsClient::handleHeader(WSclient_t * client) {
                case 101:  ///< Switching Protocols

                    break;
+                case 200:
+                    if(client->isSocketIO) {
+                        break;
+                    }
                case 403: ///< Forbidden
                    // todo handle login
                default:   ///< Server dont unterstand requrst
@ -456,6 +557,7 @@ void WebSocketsClient::handleHeader(WSclient_t * client) {
        }

        if(ok) {
+
            if(client->cAccept.length() == 0) {
                ok = false;
            } else {
@ -471,11 +573,13 @@ void WebSocketsClient::handleHeader(WSclient_t * client) {
        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());

+        } else if(clientIsConnected(client) && client->isSocketIO && client->cSessionId.length() > 0) {
+            sendHeader(client);
        } else {
            DEBUG_WEBSOCKETS("[WS-Client][handleHeader] no Websocket connection close.\n");
            client->tcp->write("This is a webSocket client!");
@ -484,3 +588,92 @@ void WebSocketsClient::handleHeader(WSclient_t * client) {
    }
 }

+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,35 +30,53 @@

 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
+

        WebSocketsClient(void);
        ~WebSocketsClient(void);

-        void begin(const char *host, uint16_t port, const char * url = "/");
-        void begin(String host, uint16_t port, String url = "/");
+        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");

 #if (WEBSOCKETS_NETWORK_TYPE == NETWORK_ESP8266)
-        void beginSSL(const char *host, uint16_t port, const char * url = "/", const char * = "");
-        void beginSSL(String host, uint16_t port, String url = "/", String fingerprint = "");
+        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");
 #endif

+        void beginSocketIO(const char *host, uint16_t port, const char * url = "/socket.io/?EIO=3", const char * protocol = "arduino");
+        void beginSocketIO(String host, uint16_t port, String url = "/socket.io/?EIO=3", String protocol = "arduino");
+
+#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);

-        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 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 sendBIN(uint8_t * payload, size_t length, bool headerToPayload = false);
-        void sendBIN(const uint8_t * payload, size_t length);
+        bool sendBIN(uint8_t * payload, size_t length, bool headerToPayload = false);
+        bool sendBIN(const uint8_t * payload, size_t length);
+
+        bool sendPing(uint8_t * payload = NULL, size_t length = 0);
+        bool sendPing(String & payload);

        void disconnect(void);

+        void setAuthorization(const char * user, const char * password);
+        void setAuthorization(const char * auth);
+
    protected:
        String _host;
        uint16_t _port;
@ -70,16 +88,24 @@ class WebSocketsClient: private WebSockets {

        WebSocketClientEvent _cbEvent;

-        void messageRecived(WSclient_t * client, WSopcode_t opcode, uint8_t * payload, size_t length);
+        void messageReceived(WSclient_t * client, WSopcode_t opcode, uint8_t * payload, size_t length);

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

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

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

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

-WebSocketsServer::WebSocketsServer(uint16_t port) {
+WebSocketsServer::WebSocketsServer(uint16_t port, String origin, String protocol) {
    _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;

+    _httpHeaderValidationFunc = NULL;
+    _mandatoryHttpHeaders = NULL;
+    _mandatoryHttpHeaderCount = 0;
 }

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

+#if (WEBSOCKETS_NETWORK_TYPE == NETWORK_ESP8266)
+    _server->close();
+#else
    // TODO how to close server?
+#endif
+
+    if (_mandatoryHttpHeaders)
+        delete[] _mandatoryHttpHeaders;
+
+    _mandatoryHttpHeaderCount = 0;
 }

 /**
- * calles to init the Websockets server
+ * called to initialize the Websocket server
 */
 void WebSocketsServer::begin(void) {
    WSclient_t * client;
@ -64,6 +86,14 @@ 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
@ -78,6 +108,7 @@ void WebSocketsServer::begin(void) {
    DEBUG_WEBSOCKETS("[WS-Server] Server Started.\n");
 }

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

 /**
 * set callback function
@ -94,40 +126,66 @@ void WebSocketsServer::onEvent(WebSocketServerEvent cbEvent) {
    _cbEvent = cbEvent;
 }

-/**
+/*
+ * Sets the custom http header validator function
+ * @param httpHeaderValidationFunc WebSocketServerHttpHeaderValFunc ///< pointer to the custom http header validation function
+ * @param mandatoryHttpHeaders[] const char* ///< the array of named http headers considered to be mandatory / must be present in order for websocket upgrade to succeed
+ * @param mandatoryHttpHeaderCount size_t ///< the number of items in the mandatoryHttpHeaders array
+ */
+void WebSocketsServer::onValidateHttpHeader(
+	WebSocketServerHttpHeaderValFunc validationFunc,
+	const char* mandatoryHttpHeaders[],
+	size_t mandatoryHttpHeaderCount)
+{
+	_httpHeaderValidationFunc = validationFunc;
+
+	if (_mandatoryHttpHeaders)
+		delete[] _mandatoryHttpHeaders;
+
+	_mandatoryHttpHeaderCount = mandatoryHttpHeaderCount;
+	_mandatoryHttpHeaders = new String[_mandatoryHttpHeaderCount];
+
+	for (size_t i = 0; i < _mandatoryHttpHeaderCount; i++) {
+		_mandatoryHttpHeaders[i] = mandatoryHttpHeaders[i];
+	}
+}
+
+/*
 * send text data to client
 * @param num uint8_t client id
 * @param payload uint8_t *
 * @param length size_t
 * @param headerToPayload bool  (see sendFrame for more details)
+ * @return true if ok
 */
-void WebSocketsServer::sendTXT(uint8_t num, uint8_t * payload, size_t length, bool headerToPayload) {
+bool WebSocketsServer::sendTXT(uint8_t num, uint8_t * payload, size_t length, bool headerToPayload) {
    if(num >= WEBSOCKETS_SERVER_CLIENT_MAX) {
-        return;
+        return false;
    }
    if(length == 0) {
        length = strlen((const char *) payload);
    }
    WSclient_t * client = &_clients[num];
    if(clientIsConnected(client)) {
-        sendFrame(client, WSop_text, payload, length, false, true, headerToPayload);
+        return sendFrame(client, WSop_text, payload, length, false, true, headerToPayload);
    }
+    return false;
 }

-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, const uint8_t * payload, size_t length) {
+    return sendTXT(num, (uint8_t *) payload, length);
 }

-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, char * payload, size_t length, bool headerToPayload) {
+    return sendTXT(num, (uint8_t *) payload, length, headerToPayload);
 }

-void WebSocketsServer::sendTXT(uint8_t num, const char * payload, size_t length) {
-    sendTXT(num, (uint8_t *) payload, length);
+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, String payload) {
-    sendTXT(num, (uint8_t *) payload.c_str(), payload.length());
+bool WebSocketsServer::sendTXT(uint8_t num, String & payload) {
+    return sendTXT(num, (uint8_t *) payload.c_str(), payload.length());
 }

 /**
@ -135,9 +193,11 @@ void 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
 */
-void WebSocketsServer::broadcastTXT(uint8_t * payload, size_t length, bool headerToPayload) {
+bool WebSocketsServer::broadcastTXT(uint8_t * payload, size_t length, bool headerToPayload) {
    WSclient_t * client;
+    bool ret = true;
    if(length == 0) {
        length = strlen((const char *) payload);
    }
@ -145,28 +205,31 @@ void 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)) {
-            sendFrame(client, WSop_text, payload, length, false, true, headerToPayload);
+            if(!sendFrame(client, WSop_text, payload, length, false, true, headerToPayload)) {
+                ret = false;
+            }
        }
-#ifdef ESP8266
+#if (WEBSOCKETS_NETWORK_TYPE == NETWORK_ESP8266)
        delay(0);
 #endif
    }
+    return ret;
 }

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

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

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

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

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

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

 /**
@ -195,24 +260,80 @@ void 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
 */
-void WebSocketsServer::broadcastBIN(uint8_t * payload, size_t length, bool headerToPayload) {
+bool 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)) {
-            sendFrame(client, WSop_binary, payload, length, false, true, headerToPayload);
+            if(!sendFrame(client, WSop_binary, payload, length, false, true, headerToPayload)) {
+                ret = false;
+            }
        }
-#ifdef ESP8266
+#if (WEBSOCKETS_NETWORK_TYPE == NETWORK_ESP8266)
        delay(0);
 #endif
    }
+    return ret;
 }

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

+
+/**
+ * sends a WS ping to Client
+ * @param num uint8_t client id
+ * @param payload uint8_t *
+ * @param length size_t
+ * @return true if ping is send out
+ */
+bool WebSocketsServer::sendPing(uint8_t num, uint8_t * payload, size_t length) {
+    if(num >= WEBSOCKETS_SERVER_CLIENT_MAX) {
+        return false;
+    }
+    WSclient_t * client = &_clients[num];
+    if(clientIsConnected(client)) {
+        return sendFrame(client, WSop_ping, payload, length);
+    }
+    return false;
+}
+
+bool WebSocketsServer::sendPing(uint8_t num, String & payload) {
+    return sendPing(num, (uint8_t *) payload.c_str(), payload.length());
+}
+
+/**
+ *  sends a WS ping to all Client
+ * @param payload uint8_t *
+ * @param length size_t
+ * @return true if ping is send out
+ */
+bool WebSocketsServer::broadcastPing(uint8_t * payload, size_t length) {
+    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_ping, payload, length)) {
+                ret = false;
+            }
+        }
+#if (WEBSOCKETS_NETWORK_TYPE == NETWORK_ESP8266)
+        delay(0);
+#endif
+    }
+    return ret;
+}
+
+bool WebSocketsServer::broadcastPing(String & payload) {
+    return broadcastPing((uint8_t *) payload.c_str(), payload.length());
+}
+
+
 /**
 * disconnect all clients
 */
@ -240,7 +361,32 @@ void WebSocketsServer::disconnect(uint8_t num) {
    }
 }

-#if (WEBSOCKETS_NETWORK_TYPE == NETWORK_ESP8266)
+
+/*
+ * set the Authorization 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)
 /**
 * get an IP for a client
 * @param num uint8_t client id
@ -262,6 +408,61 @@ 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
@ -269,7 +470,7 @@ IPAddress WebSocketsServer::remoteIP(uint8_t num) {
 * @param payload  uint8_t *
 * @param lenght size_t
 */
-void WebSocketsServer::messageRecived(WSclient_t * client, WSopcode_t opcode, uint8_t * payload, size_t lenght) {
+void WebSocketsServer::messageReceived(WSclient_t * client, WSopcode_t opcode, uint8_t * payload, size_t lenght) {
    WStype_t type = WStype_ERROR;

    switch(opcode) {
@ -306,10 +507,16 @@ 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;
    }

@ -320,6 +527,12 @@ 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);
@ -331,7 +544,7 @@ void WebSocketsServer::clientDisconnect(WSclient_t * client) {
 /**
 * get client state
 * @param client WSclient_t *  ptr to the client struct
- * @return true = conneted
+ * @return true = connected
 */
 bool WebSocketsServer::clientIsConnected(WSclient_t * client) {

@ -354,76 +567,56 @@ 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
+ * Handle incoming 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)
-                client->isSSL = false;
-                client->tcp->setNoDelay(true);
-#endif
-                // 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]);
+        // store new connection
+        WEBSOCKETS_NETWORK_CLASS * tcpClient = new WEBSOCKETS_NETWORK_CLASS(_server->available());
 #else
-                DEBUG_WEBSOCKETS("[WS-Server][%d] new client\n", client->num);
+        WEBSOCKETS_NETWORK_CLASS * tcpClient = new WEBSOCKETS_NETWORK_CLASS(_server->available());
 #endif
-                ok = true;
-                break;
-            }
+
+        if(!tcpClient) {
+            DEBUG_WEBSOCKETS("[WS-Client] creating Network class failed!");
+            return;
        }

+        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 = client->tcp->remoteIP();
+            IPAddress ip = tcpClient->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();
        }

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

+
 /**
 * Handel incomming data from Client
 */
@ -435,10 +628,13 @@ 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:
-                        handleHeader(client);
+                    {
+                        String headerLine = client->tcp->readStringUntil('\n');
+                        handleHeader(client, &headerLine);
+                    }
                        break;
                    case WSC_CONNECTED:
                        WebSockets::handleWebsocket(client);
@ -449,34 +645,54 @@ void WebSocketsServer::handleClientData(void) {
                }
            }
        }
-#ifdef ESP8266
+#if (WEBSOCKETS_NETWORK_TYPE == NETWORK_ESP8266)
        delay(0);
 #endif
    }
 }
+#endif
+
+/*
+ * returns an indicator whether the given named header exists in the configured _mandatoryHttpHeaders collection
+ * @param headerName String ///< the name of the header being checked
+ */
+bool WebSocketsServer::hasMandatoryHeader(String headerName) {
+	for (size_t i = 0; i < _mandatoryHttpHeaderCount; i++) {
+		if (_mandatoryHttpHeaders[i].equalsIgnoreCase(headerName))
+			return true;
+	}
+	return false;
+}

 /**
- * handle the WebSocket header reading
- * @param client WSclient_t *  ptr to the client struct
+ * handles http header reading for WebSocket upgrade
+ * @param client WSclient_t * ///< pointer to the client struct
+ * @param headerLine String ///< the header being read / processed
 */
-void WebSocketsServer::handleHeader(WSclient_t * client) {
+void WebSocketsServer::handleHeader(WSclient_t * client, String * headerLine) {

-    String headerLine = client->tcp->readStringUntil('\n');
-    headerLine.trim(); // remove \r
+    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 requests always start with GET see rfc6455
+        if(headerLine->startsWith("GET ")) {

-        // websocket request starts allways with GET see rfc6455
-        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));
+
+            //reset non-websocket http header validation state for this client
+			client->cHttpHeadersValid = true;
+			client->cMandatoryHeadersCount = 0;
+
+        } 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) {
+                headerValue.toLowerCase();
+            	if(headerValue.indexOf("upgrade") >= 0) {
                    client->cIsUpgrade = true;
                }
            } else if(headerName.equalsIgnoreCase("Upgrade")) {
@ -492,14 +708,26 @@ void WebSocketsServer::handleHeader(WSclient_t * client) {
                client->cProtocol = headerValue;
            } else if(headerName.equalsIgnoreCase("Sec-WebSocket-Extensions")) {
                client->cExtensions = headerValue;
+            } else if(headerName.equalsIgnoreCase("Authorization")) {
+                client->base64Authorization = headerValue;
+            } else {
+            	client->cHttpHeadersValid &= execHttpHeaderValidation(headerName, headerValue);
+            	if (_mandatoryHttpHeaderCount > 0 && hasMandatoryHeader(headerName)) {
+            		client->cMandatoryHeadersCount++;
+            	}
            }
+
        } 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);

+        DEBUG_WEBSOCKETS("[WS-Server][%d][handleHeader] Header read fin.\n", client->num);
        DEBUG_WEBSOCKETS("[WS-Server][%d][handleHeader]  - cURL: %s\n", client->num, client->cUrl.c_str());
        DEBUG_WEBSOCKETS("[WS-Server][%d][handleHeader]  - cIsUpgrade: %d\n", client->num, client->cIsUpgrade);
        DEBUG_WEBSOCKETS("[WS-Server][%d][handleHeader]  - cIsWebsocket: %d\n", client->num, client->cIsWebsocket);
@ -507,6 +735,9 @@ void WebSocketsServer::handleHeader(WSclient_t * client) {
        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.c_str());
+        DEBUG_WEBSOCKETS("[WS-Server][%d][handleHeader]  - cHttpHeadersValid: %d\n", client->num, client->cHttpHeadersValid);
+        DEBUG_WEBSOCKETS("[WS-Server][%d][handleHeader]  - cMandatoryHeadersCount: %d\n", client->num, client->cMandatoryHeadersCount);

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

@ -520,11 +751,31 @@ void WebSocketsServer::handleHeader(WSclient_t * client) {
            if(client->cVersion != 13) {
                ok = false;
            }
+            if(!client->cHttpHeadersValid) {
+            	ok = false;
+            }
+            if (client->cMandatoryHeadersCount != _mandatoryHttpHeaderCount) {
+            	ok = false;
+            }
+        }
+
+        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 incomming.\n", client->num);
+            DEBUG_WEBSOCKETS("[WS-Server][%d][handleHeader] Websocket connection incoming.\n", client->num);

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

            if(client->cProtocol.length() > 0) {
-                // TODO add api to set Protocol of Server
-                client->tcp->write("Sec-WebSocket-Protocol: arduino\r\n");
+                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");
            }

            // 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,64 +36,99 @@
 class WebSocketsServer: private WebSockets {
 public:

+#ifdef __AVR__
        typedef void (*WebSocketServerEvent)(uint8_t num, WStype_t type, uint8_t * payload, size_t length);
+        typedef bool (*WebSocketServerHttpHeaderValFunc)(String headerName, String headerValue);
+#else
+        typedef std::function<void (uint8_t num, WStype_t type, uint8_t * payload, size_t length)> WebSocketServerEvent;
+        typedef std::function<bool (String headerName, String headerValue)> WebSocketServerHttpHeaderValFunc;
+#endif

-        WebSocketsServer(uint16_t port);
+        WebSocketsServer(uint16_t port, String origin = "", String protocol = "arduino");
        ~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);
+        void onValidateHttpHeader(
+			WebSocketServerHttpHeaderValFunc validationFunc,
+			const char* mandatoryHttpHeaders[],
+			size_t mandatoryHttpHeaderCount);


-        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 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 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 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 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 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 broadcastBIN(uint8_t * payload, size_t length, bool headerToPayload = false);
-        void broadcastBIN(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);
+
+        bool sendPing(uint8_t num, uint8_t * payload = NULL, size_t length = 0);
+        bool sendPing(uint8_t num, String & payload);
+
+        bool broadcastPing(uint8_t * payload = NULL, size_t length = 0);
+        bool broadcastPing(String & payload);

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

-#if (WEBSOCKETS_NETWORK_TYPE == NETWORK_ESP8266)
+        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)
        IPAddress remoteIP(uint8_t num);
 #endif

 protected:
        uint16_t _port;
+        String _origin;
+        String _protocol;
+        String _base64Authorization; ///< Base64 encoded Auth request
+        String * _mandatoryHttpHeaders;
+        size_t _mandatoryHttpHeaderCount;

        WEBSOCKETS_NETWORK_SERVER_CLASS * _server;

        WSclient_t _clients[WEBSOCKETS_SERVER_CLIENT_MAX];

        WebSocketServerEvent _cbEvent;
+        WebSocketServerHttpHeaderValFunc _httpHeaderValidationFunc;

-        void messageRecived(WSclient_t * client, WSopcode_t opcode, uint8_t * payload, size_t length);
+        bool newClient(WEBSOCKETS_NETWORK_CLASS * TCPclient);
+
+        void messageReceived(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);
+        void handleHeader(WSclient_t * client, String * headerLine);

        /**
-         * called if a non Websocket connection is comming in.
-         * Note: can be overrided
+         * called if a non Websocket connection is coming in.
+         * Note: can be override
         * @param client WSclient_t *  ptr to the client struct
         */
        virtual void handleNonWebsocketConnection(WSclient_t * client) {
@ -109,6 +144,25 @@ 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
@ -122,6 +176,30 @@ protected:
            }
        }

+        /*
+         * Called at client socket connect handshake negotiation time for each http header that is not
+         * a websocket specific http header (not Connection, Upgrade, Sec-WebSocket-*)
+         * If the custom httpHeaderValidationFunc returns false for any headerName / headerValue passed, the
+         * socket negotiation is considered invalid and the upgrade to websockets request is denied / rejected
+         * This mechanism can be used to enable custom authentication schemes e.g. test the value
+         * of a session cookie to determine if a user is logged on / authenticated
+         */
+        virtual bool execHttpHeaderValidation(String headerName, String headerValue) {
+        	if(_httpHeaderValidationFunc) {
+        		//return the value of the custom http header validation function
+        		return _httpHeaderValidationFunc(headerName, headerValue);
+        	}
+        	//no custom http header validation so just assume all is good
+        	return true;
+        }
+
+private:
+        /*
+         * returns an indicator whether the given named header exists in the configured _mandatoryHttpHeaders collection
+         * @param headerName String ///< the name of the header being checked
+         */
+        bool hasMandatoryHeader(String headerName);
+
 };


--- a/tests/webSocket.html
+++ b/tests/webSocket.html
@ -8,10 +8,11 @@ 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) {
@ -20,6 +21,7 @@ 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);
        }
    });
Author	SHA1	Message	Date
Markus Sattler	d2719573d4	add function to send WS ping sendPing(); #130	2016-10-22 19:47:44 +02:00
Markus	0d9aa043f0	fix WebSocketClientSocketIO example	2016-10-22 20:36:36 +02:00
Markus	1defe6d8e1	Merge pull request #126 from Roman3349/master Add information about library to @PlatformIO Library Registry manifest file	2016-09-28 18:28:28 +02:00
Roman3349	d036dcd8e2	Add information about examples, license and version to @PlatformIO Library Registry manifest file Signed-off-by: Roman3349 <ondracek.roman@centrum.cz>	2016-09-27 11:25:56 +02:00
Markus	529a86cc26	Merge pull request #90 from kenkus-futurice/master Add socket.io client	2016-09-11 17:13:57 +02:00
Markus	958ab08a6b	Merge pull request #111 from anisimovsergey/master WEBSOCKETS_NETWORK_TYPE exteral definition	2016-07-15 21:44:03 +02:00
Sergey Anisimov	7361e2b1b6	WEBSOCKETS_NETWORK_TYPE exteral definition Making possible to define WEBSOCKETS_NETWORK_TYPE as a compile parameter.	2016-07-15 20:29:13 +01:00
Markus Sattler	1961ddc159	bump git version	2016-07-11 17:30:08 +02:00
Markus Sattler	cdee9fec05	release version 2.0.4	2016-07-11 17:29:29 +02:00
Markus	ab0d8ff526	Merge pull request #100 from chrisella/master fix spellings	2016-06-18 12:39:40 +02:00
cella	b3d4367d10	fix spellings	2016-06-17 15:37:07 +01:00
Markus	ab51930730	Merge pull request #93 from jjssoftware/HttpHeaderEvents custom http header validation implementation	2016-06-13 21:01:14 +02:00
Joe	1ed734ec3f	Merge pull request #2 from jlippa/master pull from master	2016-06-11 13:13:16 +01:00
Joe	b99bae459d	Merge pull request #1 from Links2004/master pull from head	2016-06-11 13:05:44 +01:00
Markus	26130dc874	Merge pull request #95 from jlippa/Docs wss / SSL README.md documentation update	2016-06-11 13:35:28 +02:00
joe	815093a123	wss / SSL README.md documentation update	2016-06-11 10:17:13 +01:00
joe	7e5c64a573	mandatoryHttpHeaderCount fix	2016-06-09 19:48:38 +01:00
joe	97443ae777	custom http header validation implementation; minor comment fixes	2016-06-08 23:11:21 +01:00
joe	e589b40b25	custom http header validation implementation	2016-06-08 23:04:18 +01:00
Markus	eb2351a4fd	Merge pull request #89 from jlippa/nginx Added sample ESP8266 nginx SSL reverse proxy configuration file	2016-06-07 18:02:50 +02:00
Kenta Kusumoto	bf3cfa6237	Fix reference to INTERVAL	2016-06-06 17:50:31 +03:00
Kenta Kusumoto	f8a5acc9b7	Add socket.io client	2016-06-06 15:21:13 +03:00
joe	8190e8121c	Added sample ESP8266 nginx SSL reverse proxy configuration file	2016-06-05 16:09:22 +01:00
Markus	6a914fc5ea	Merge pull request #87 from jlippa/master RFC 6455 4.2.1.4 case sensitivity fix	2016-06-05 09:58:46 +02:00
jlippa	48ee5fc6fb	Firefox fix Overlay fix for Firefox and other clients that send additional data in the Connection header e.g. "Connection: Keep-Alive, Upgrade"	2016-06-05 08:27:39 +01:00
jlippa	b1685962c5	Merge pull request #1 from jlippa/jlippa-patch-1 RFC 6455 4.2.1.4 case sensitivity fix	2016-06-04 21:32:44 +01:00
jlippa	c4e5f5c7e7	RFC 6455 4.2.1.4 case sensitivity fix This is a case sensitivity fix for the Connection header Upgrade value to make this part meet the requirement of IETF websocket RFC 6455 4.2.1.4: "A \|Connection\| header field that includes the token "Upgrade", treated as an ASCII case-insensitive value."	2016-06-04 21:31:42 +01:00
Markus	6972f7a84e	Merge pull request #74 from wnemay/master Adjustments to headers during client handshake.	2016-05-10 18:02:09 +02:00
Markus	93b0b9eeaf	Merge pull request #77 from thorstenfreitag/master Compatibility for broken servers and additional authentication option instead of just basic	2016-05-10 17:52:30 +02:00
Thorsten Freitag	dd14850bb6	Used case insensitive recognition for upgrade header. Should work as before, but also with servers that wrongly use lower case upgrade in the header	2016-05-10 11:56:01 +10:00
Thorsten Freitag	d36f7bb100	Changed Header value to lower case upgrade, seems to fix connection issues with SAP HCP IoT services. Changed setAuthorization(const char * auth) to send Auth header as is, without BASIC to enable oAuth tokens in header	2016-05-09 00:11:42 +10:00
Wayne May	10a8d3ca67	Adding Origin, as required by spec. https://tools.ietf.org/html/rfc6455#section-1.6	2016-04-30 20:55:59 -07:00
Wayne May	4f55c36c80	RFC requires a port for Host when it is non default. https://www.w3.org/Protocols/rfc2616/rfc2616-sec14.html#sec14.23	2016-04-30 15:46:19 -07:00
Markus Sattler	b3efb316ed	bump version	2016-03-16 16:25:57 +01:00
Markus Sattler	ea997cf977	update README.md	2016-03-16 16:25:31 +01:00
Markus Sattler	a103bb915c	Merge remote-tracking branch 'remotes/origin/async'	2016-03-16 16:23:50 +01:00
Markus	bc58d75d71	Merge pull request #59 from uncletammy/patch-1 Added note about delay() limitation.	2016-03-16 16:23:26 +01:00
Markus	d7be7cd2fe	Merge pull request #64 from urish/patch-1 fix typo: lenght -> length	2016-03-16 15:55:00 +01:00
Markus	73faf7e6b6	Merge pull request #65 from urish/patch-2 Make the `Sec-WebSocket-Protocol` header optional	2016-03-16 15:54:26 +01:00
Uri Shaked	00be8c7833	Make the `Sec-WebSocket-Protocol` header optional Some server implementations (e.g. slack bots api) don't accept the connection if `Sec-WebSocket-Protocol` is specified.	2016-03-16 11:55:21 +02:00
Uri Shaked	5b4eaa0b11	fix typo: lenght -> length	2016-03-16 03:28:21 +02:00
Markus Sattler	8988faf5f0	fix #60 os_printf can not handle String direct	2016-03-05 12:13:13 +01:00
Nicholas Crumrine	1ebae1d3e1	Add note about delay() limitation. Change concerns issue https://github.com/Links2004/arduinoWebSockets/issues/58	2016-03-04 14:19:19 -06:00
Markus Sattler	49a2a9ab4f	update README.md	2016-02-20 12:30:38 +01:00
Markus Sattler	450ca76a74	add return value to all send functions	2016-02-20 12:27:19 +01:00
Markus Sattler	c57a4c19ab	add HTTP Basic Authorization to WS Client and Server see: #55	2016-02-17 17:56:03 +01:00
Markus Sattler	2d87bfa3d6	less ram usage when using strings	2016-02-06 19:21:24 +01:00
Markus Sattler	2b6f1909d7	add ESP31B to compatible list	2016-01-30 12:02:09 +01:00
Markus Sattler	16824906c8	increase timeout to 2000ms sync TCP is default	2016-01-30 12:01:09 +01:00
Markus Sattler	632ee13230	Merge remote-tracking branch 'remotes/me-no-dev/async' into async	2016-01-30 11:59:33 +01:00
Me No Dev	512e3f6c09	add ESP31B support and fix header size	2016-01-30 02:24:29 +02:00
Markus Sattler	629f524ea4	fix c&p error in handling of more then 125 byte	2016-01-30 00:34:00 +01:00
Markus Sattler	63f8675816	update README.md	2016-01-29 13:52:27 +01:00
Markus Sattler	b7a694c16a	add note for async mode	2016-01-29 13:28:05 +01:00
Markus Sattler	0a8a8979ef	Merge remote-tracking branch 'remotes/origin/master' into async Conflicts: src/WebSockets.h	2016-01-29 13:22:15 +01:00
Markus Sattler	76853c7a73	async client working	2016-01-29 13:16:02 +01:00
Markus	005441d5f8	Merge pull request #43 from brtiberio/master add possibilty to define subprotocol of websockets client	2016-01-26 19:55:02 +01:00
Bruno Tibério	358d8c769e	added subprotocol for ssl client also	2016-01-24 17:08:22 +00:00
Markus Sattler	1275914c86	first parts of client working	2016-01-24 00:52:23 +01:00
Markus Sattler	790a922d5a	add deprecated warning for loop in async mode fix sync mode	2016-01-23 18:41:45 +01:00
Markus Sattler	5c2c257526	fix server disconnect problems	2016-01-23 18:34:30 +01:00
Markus Sattler	57e30e0634	First steps to do async	2016-01-23 16:27:02 +01:00
Bruno Tibério	3e0b0bd377	updated with upstream, added subprotocol to client	2016-01-20 23:56:09 +00:00
Markus Sattler	ece771a275	add support for setting: - Access-Control-Allow-Origin (#25) - Sec-WebSocket-Protocol () add _server->close(); for ESP	2016-01-14 17:28:00 +01:00
Markus Sattler	cf7652a371	allow usage of std::bind for Event callback	2016-01-11 10:37:27 +01:00