fix #525 (detect ESP32 vesion)

Initialize _reconnectInterval in constructor.

.clang-format

@@ -0,0 +1,63 @@
+---
+BasedOnStyle: Google
+AccessModifierOffset: '-2'
+AlignAfterOpenBracket: DontAlign
+AlignConsecutiveAssignments: 'true'
+AlignConsecutiveDeclarations: 'false'
+AlignEscapedNewlines: Left
+AlignTrailingComments: 'true'
+AllowAllParametersOfDeclarationOnNextLine: 'false'
+AllowShortBlocksOnASingleLine: 'false'
+AllowShortCaseLabelsOnASingleLine: 'false'
+AllowShortFunctionsOnASingleLine: InlineOnly
+AllowShortIfStatementsOnASingleLine: 'true'
+AllowShortLoopsOnASingleLine: 'true'
+AlwaysBreakAfterDefinitionReturnType: None
+AlwaysBreakAfterReturnType: None
+AlwaysBreakBeforeMultilineStrings: 'true'
+AlwaysBreakTemplateDeclarations: 'false'
+BinPackParameters: 'true'
+BreakAfterJavaFieldAnnotations: 'false'
+BreakBeforeBinaryOperators: None
+BreakBeforeBraces: Attach
+BreakBeforeInheritanceComma: 'false'
+BreakBeforeTernaryOperators: 'false'
+BreakConstructorInitializers: BeforeColon
+BreakStringLiterals: 'false'
+ColumnLimit: '0'
+CompactNamespaces: 'true'
+ConstructorInitializerAllOnOneLineOrOnePerLine: 'true'
+ConstructorInitializerIndentWidth: '4'
+ContinuationIndentWidth: '4'
+Cpp11BracedListStyle: 'false'
+DerivePointerAlignment: 'false'
+FixNamespaceComments: 'true'
+IndentCaseLabels: 'true'
+IndentWidth: '4'
+IndentWrappedFunctionNames: 'false'
+JavaScriptQuotes: Single
+JavaScriptWrapImports: 'false'
+KeepEmptyLinesAtTheStartOfBlocks: 'false'
+MaxEmptyLinesToKeep: '1'
+NamespaceIndentation: All
+ObjCBlockIndentWidth: '4'
+ObjCSpaceAfterProperty: 'false'
+ObjCSpaceBeforeProtocolList: 'false'
+PointerAlignment: Middle
+SortIncludes: 'false'
+SortUsingDeclarations: 'true'
+SpaceAfterCStyleCast: 'false'
+SpaceAfterTemplateKeyword: 'false'
+SpaceBeforeAssignmentOperators: 'true'
+SpaceBeforeParens: Never
+SpaceInEmptyParentheses: 'false'
+SpacesBeforeTrailingComments: '4'
+SpacesInAngles: 'false'
+SpacesInCStyleCastParentheses: 'false'
+SpacesInContainerLiterals: 'false'
+SpacesInParentheses: 'false'
+SpacesInSquareBrackets: 'false'
+TabWidth: '4'
+UseTab: Never
+
+...

.gitignore

@@ -27,3 +27,11 @@
 *.out
 *.app
 /tests/webSocketServer/node_modules
+
+# IDE
+.vscode
+.cproject
+.project
+.settings
+*.swp
+

.travis.yml

@@ -1,31 +1,44 @@
 sudo: false
+dist:
+  - xenial
+addons:
+  apt:
+    packages:
+      - xvfb
 language: bash
 os:
   - linux
 env:
   matrix:
-    - CPU="esp8266" BOARD="esp8266com:esp8266:generic:CpuFrequency=80" IDE_VERSION=1.6.5
-    - CPU="esp8266" BOARD="esp8266com:esp8266:generic:CpuFrequency=80,FlashSize=1M0,FlashMode=qio,FlashFreq=80" IDE_VERSION=1.8.5
-    - CPU="esp8266" BOARD="esp8266com:esp8266:generic:CpuFrequency=80,Debug=Serial1" IDE_VERSION=1.6.5
-    - CPU="esp32" BOARD="espressif:esp32:esp32:FlashFreq=80" IDE_VERSION=1.6.5
+    - CPU="esp8266" BOARD="esp8266com:esp8266:generic:xtal=80" IDE_VERSION=1.6.5
+    - CPU="esp8266" BOARD="esp8266com:esp8266:generic:xtal=80,dbg=Serial1" IDE_VERSION=1.6.5
+    - CPU="esp8266" BOARD="esp8266com:esp8266:generic:xtal=80,eesz=1M,FlashMode=qio,FlashFreq=80" IDE_VERSION=1.8.5
+    - CPU="esp8266" BOARD="esp8266com:esp8266:generic:xtal=80,eesz=1M,FlashMode=qio,FlashFreq=80" IDE_VERSION=1.8.9
+    - CPU="esp8266" BOARD="esp8266com:esp8266:generic:xtal=80,eesz=1M,FlashMode=qio,FlashFreq=80" IDE_VERSION=1.8.12
     - CPU="esp32" BOARD="espressif:esp32:esp32:FlashFreq=80" IDE_VERSION=1.8.5
-
+    - CPU="esp32" BOARD="espressif:esp32:esp32:FlashFreq=80" IDE_VERSION=1.8.9
+    - CPU="esp32" BOARD="espressif:esp32:esp32:FlashFreq=80" IDE_VERSION=1.8.12
 script:
   - /sbin/start-stop-daemon --start --quiet --pidfile /tmp/custom_xvfb_1.pid --make-pidfile --background --exec /usr/bin/Xvfb -- :1 -ac -screen 0 1280x1024x16
-  - sleep 3
   - export DISPLAY=:1.0
+  - sleep 3
   - wget http://downloads.arduino.cc/arduino-$IDE_VERSION-linux64.tar.xz
   - tar xf arduino-$IDE_VERSION-linux64.tar.xz
   - mv arduino-$IDE_VERSION $HOME/arduino_ide
   - export PATH="$HOME/arduino_ide:$PATH"
   - which arduino
   - mkdir -p $HOME/Arduino/libraries
+
+  - wget https://github.com/bblanchon/ArduinoJson/archive/6.x.zip
+  - unzip 6.x.zip
+  - mv ArduinoJson-6.x $HOME/Arduino/libraries/ArduinoJson
   - cp -r $TRAVIS_BUILD_DIR $HOME/Arduino/libraries/arduinoWebSockets
   - source $TRAVIS_BUILD_DIR/travis/common.sh
   - get_core $CPU
   - cd $TRAVIS_BUILD_DIR
   - arduino --board $BOARD --save-prefs
   - arduino --get-pref sketchbook.path
+  - arduino --pref update.check=false
   - build_sketches arduino $HOME/Arduino/libraries/arduinoWebSockets/examples/$CPU $CPU
 
 notifications:

README.md

@@ -57,22 +57,22 @@ The mode can be activated in the ```WebSockets.h``` (see WEBSOCKETS_NETWORK_TYPE
 ### High Level Client API ###
 
  - `begin` : Initiate connection sequence to the websocket host.
-```
+```c++
 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");
  ```
  - `onEvent`: Callback to handle for websocket events
 
- ```
+ ```c++
  void onEvent(WebSocketClientEvent cbEvent);
  ```
 
  - `WebSocketClientEvent`: Handler for websocket events
- ```
+ ```c++
  void (*WebSocketClientEvent)(WStype_t type, uint8_t * payload, size_t length)
  ```
 Where `WStype_t type` is defined as:
-  ```
+  ```c++
   typedef enum {
       WStype_ERROR,
       WStype_DISCONNECTED,

examples/esp8266/WebSocketClient/WebSocketClient.ino

@@ -45,7 +45,15 @@ void webSocketEvent(WStype_t type, uint8_t * payload, size_t length) {
 			// send data to server
 			// webSocket.sendBIN(payload, length);
 			break;
-	}
+        case WStype_PING:
+            // pong will be send automatically
+            USE_SERIAL.printf("[WSc] get ping\n");
+            break;
+        case WStype_PONG:
+            // answer to a ping we send
+            USE_SERIAL.printf("[WSc] get pong\n");
+            break;
+    }
 
 }
 
@@ -84,6 +92,12 @@ void setup() {
 
 	// try ever 5000 again if connection has failed
 	webSocket.setReconnectInterval(5000);
+  
+  // start heartbeat (optional)
+  // ping server every 15000 ms
+  // expect pong from server within 3000 ms
+  // consider connection disconnected if pong is not received 2 times
+  webSocket.enableHeartbeat(15000, 3000, 2);
 
 }
 

examples/esp8266/WebSocketClientSocketIO/WebSocketClientSocketIO.ino

@@ -10,56 +10,46 @@
 #include <ESP8266WiFi.h>
 #include <ESP8266WiFiMulti.h>
 
+#include <ArduinoJson.h>
+
 #include <WebSocketsClient.h>
+#include <SocketIOclient.h>
 
 #include <Hash.h>
 
 ESP8266WiFiMulti WiFiMulti;
-WebSocketsClient webSocket;
-
+SocketIOclient socketIO;
 
 #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 length) {
-
-
+void socketIOEvent(socketIOmessageType_t type, uint8_t * payload, size_t length) {
     switch(type) {
-        case WStype_DISCONNECTED:
-            USE_SERIAL.printf("[WSc] Disconnected!\n");
-            isConnected = false;
+        case sIOtype_DISCONNECT:
+            USE_SERIAL.printf("[IOc] Disconnected!\n");
             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");
-            }
+        case sIOtype_CONNECT:
+            USE_SERIAL.printf("[IOc] Connected to url: %s\n", payload);
             break;
-        case WStype_TEXT:
-            USE_SERIAL.printf("[WSc] get text: %s\n", payload);
-
-			// send message to server
-			// webSocket.sendTXT("message here");
+        case sIOtype_EVENT:
+            USE_SERIAL.printf("[IOc] get event: %s\n", payload);
             break;
-        case WStype_BIN:
-            USE_SERIAL.printf("[WSc] get binary length: %u\n", length);
+        case sIOtype_ACK:
+            USE_SERIAL.printf("[IOc] get ack: %u\n", length);
+            hexdump(payload, length);
+            break;
+        case sIOtype_ERROR:
+            USE_SERIAL.printf("[IOc] get error: %u\n", length);
+            hexdump(payload, length);
+            break;
+        case sIOtype_BINARY_EVENT:
+            USE_SERIAL.printf("[IOc] get binary: %u\n", length);
+            hexdump(payload, length);
+            break;
+        case sIOtype_BINARY_ACK:
+            USE_SERIAL.printf("[IOc] get binary ack: %u\n", length);
             hexdump(payload, length);
-
-            // send data to server
-            // webSocket.sendBIN(payload, length);
             break;
     }
-
 }
 
 void setup() {
@@ -79,6 +69,11 @@ void setup() {
           delay(1000);
       }
 
+    // disable AP
+    if(WiFi.getMode() & WIFI_AP) {
+        WiFi.softAPdisconnect(true);
+    }
+
     WiFiMulti.addAP("SSID", "passpasspass");
 
     //WiFi.disconnect();
@@ -86,28 +81,45 @@ void setup() {
         delay(100);
     }
 
-    webSocket.beginSocketIO("192.168.0.123", 81);
-    //webSocket.setAuthorization("user", "Password"); // HTTP Basic Authorization
-    webSocket.onEvent(webSocketEvent);
+    String ip = WiFi.localIP().toString();
+    USE_SERIAL.printf("[SETUP] WiFi Connected %s\n", ip.c_str());
 
+    // server address, port and URL
+    socketIO.begin("10.11.100.100", 8880);
+
+    // event handler
+    socketIO.onEvent(socketIOEvent);
 }
 
+unsigned long messageTimestamp = 0;
 void loop() {
-    webSocket.loop();
+    socketIO.loop();
 
-    if(isConnected) {
+    uint64_t now = millis();
 
-        uint64_t now = millis();
+    if(now - messageTimestamp > 2000) {
+        messageTimestamp = now;
 
-        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");
-        }
+        // creat JSON message for Socket.IO (event)
+        DynamicJsonDocument doc(1024);
+        JsonArray array = doc.to<JsonArray>();
+        
+        // add evnet name
+        // Hint: socket.on('event_name', ....
+        array.add("event_name");
+
+        // add payload (parameters) for the event
+        JsonObject param1 = array.createNestedObject();
+        param1["now"] = now;
+
+        // JSON to String (serializion)
+        String output;
+        serializeJson(doc, output);
+
+        // Send event        
+        socketIO.sendEVENT(output);
+
+        // Print JSON for debugging
+        USE_SERIAL.println(output);
     }
 }

examples/esp8266/WebSocketClientSocketIOack/WebSocketClientSocketIOack.ino

@@ -0,0 +1,162 @@
+/*
+ * WebSocketClientSocketIOack.ino
+ *
+ *  Created on: 20.07.2019
+ *
+ */
+
+#include <Arduino.h>
+
+#include <ESP8266WiFi.h>
+#include <ESP8266WiFiMulti.h>
+
+#include <ArduinoJson.h>
+
+#include <WebSocketsClient.h>
+#include <SocketIOclient.h>
+
+#include <Hash.h>
+
+ESP8266WiFiMulti WiFiMulti;
+SocketIOclient socketIO;
+
+#define USE_SERIAL Serial
+
+
+void socketIOEvent(socketIOmessageType_t type, uint8_t * payload, size_t length) {
+    switch(type) {
+        case sIOtype_DISCONNECT:
+            USE_SERIAL.printf("[IOc] Disconnected!\n");
+            break;
+        case sIOtype_CONNECT:
+            USE_SERIAL.printf("[IOc] Connected to url: %s\n", payload);
+            break;
+        case sIOtype_EVENT:
+        {
+            char * sptr = NULL;
+            int id = strtol((char *)payload, &sptr, 10);
+            USE_SERIAL.printf("[IOc] get event: %s id: %d\n", payload, id);
+            if(id) {
+                payload = (uint8_t *)sptr;
+            }
+            DynamicJsonDocument doc(1024);
+            DeserializationError error = deserializeJson(doc, payload, length);
+            if(error) {
+                USE_SERIAL.print(F("deserializeJson() failed: "));
+                USE_SERIAL.println(error.c_str());
+                return;
+            }
+            
+            String eventName = doc[0];
+            USE_SERIAL.printf("[IOc] event name: %s\n", eventName.c_str());
+
+            // Message Includes a ID for a ACK (callback)
+            if(id) {
+                // creat JSON message for Socket.IO (ack)
+                DynamicJsonDocument docOut(1024);
+                JsonArray array = docOut.to<JsonArray>();
+                
+                // add payload (parameters) for the ack (callback function)
+                JsonObject param1 = array.createNestedObject();
+                param1["now"] = millis();
+
+                // JSON to String (serializion)
+                String output;
+                output += id;
+                serializeJson(docOut, output);
+
+                // Send event        
+                socketIO.send(sIOtype_ACK, output);
+            }
+        }
+            break;
+        case sIOtype_ACK:
+            USE_SERIAL.printf("[IOc] get ack: %u\n", length);
+            hexdump(payload, length);
+            break;
+        case sIOtype_ERROR:
+            USE_SERIAL.printf("[IOc] get error: %u\n", length);
+            hexdump(payload, length);
+            break;
+        case sIOtype_BINARY_EVENT:
+            USE_SERIAL.printf("[IOc] get binary: %u\n", length);
+            hexdump(payload, length);
+            break;
+        case sIOtype_BINARY_ACK:
+            USE_SERIAL.printf("[IOc] get binary ack: %u\n", length);
+            hexdump(payload, length);
+            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);
+      }
+
+    // disable AP
+    if(WiFi.getMode() & WIFI_AP) {
+        WiFi.softAPdisconnect(true);
+    }
+
+    WiFiMulti.addAP("SSID", "passpasspass");
+
+    //WiFi.disconnect();
+    while(WiFiMulti.run() != WL_CONNECTED) {
+        delay(100);
+    }
+
+    String ip = WiFi.localIP().toString();
+    USE_SERIAL.printf("[SETUP] WiFi Connected %s\n", ip.c_str());
+
+    // server address, port and URL
+    socketIO.begin("10.11.100.100", 8880);
+
+    // event handler
+    socketIO.onEvent(socketIOEvent);
+}
+
+unsigned long messageTimestamp = 0;
+void loop() {
+    socketIO.loop();
+
+    uint64_t now = millis();
+
+    if(now - messageTimestamp > 2000) {
+        messageTimestamp = now;
+
+        // creat JSON message for Socket.IO (event)
+        DynamicJsonDocument doc(1024);
+        JsonArray array = doc.to<JsonArray>();
+        
+        // add evnet name
+        // Hint: socket.on('event_name', ....
+        array.add("event_name");
+
+        // add payload (parameters) for the event
+        JsonObject param1 = array.createNestedObject();
+        param1["now"] = now;
+
+        // JSON to String (serializion)
+        String output;
+        serializeJson(doc, output);
+
+        // Send event        
+        socketIO.sendEVENT(output);
+
+        // Print JSON for debugging
+        USE_SERIAL.println(output);
+    }
+}

library.json

@@ -13,7 +13,7 @@
         "type": "git",
         "url": "https://github.com/Links2004/arduinoWebSockets.git"
     },
-    "version": "2.1.1",
+    "version": "2.2.1",
     "license": "LGPL-2.1",
     "export": {
         "exclude": [

library.properties

@@ -1,5 +1,5 @@
 name=WebSockets
-version=2.1.1
+version=2.2.1
 author=Markus Sattler
 maintainer=Markus Sattler
 sentence=WebSockets for Arduino (Server + Client)

src/SocketIOclient.cpp

@@ -0,0 +1,201 @@
+/*
+ * SocketIOclient.cpp
+ *
+ *  Created on: May 12, 2018
+ *      Author: links
+ */
+
+#include "WebSockets.h"
+#include "WebSocketsClient.h"
+#include "SocketIOclient.h"
+
+SocketIOclient::SocketIOclient() {
+}
+
+SocketIOclient::~SocketIOclient() {
+}
+
+void SocketIOclient::begin(const char * host, uint16_t port, const char * url, const char * protocol) {
+    WebSocketsClient::beginSocketIO(host, port, url, protocol);
+    WebSocketsClient::enableHeartbeat(60 * 1000, 90 * 1000, 5);
+}
+
+void SocketIOclient::begin(String host, uint16_t port, String url, String protocol) {
+    WebSocketsClient::beginSocketIO(host, port, url, protocol);
+    WebSocketsClient::enableHeartbeat(60 * 1000, 90 * 1000, 5);
+}
+
+/**
+ * set callback function
+ * @param cbEvent SocketIOclientEvent
+ */
+void SocketIOclient::onEvent(SocketIOclientEvent cbEvent) {
+    _cbEvent = cbEvent;
+}
+
+bool SocketIOclient::isConnected(void) {
+    return WebSocketsClient::isConnected();
+}
+
+/**
+ * send text data to client
+ * @param num uint8_t client id
+ * @param type socketIOmessageType_t
+ * @param payload uint8_t *
+ * @param length size_t
+ * @param headerToPayload bool (see sendFrame for more details)
+ * @return true if ok
+ */
+bool SocketIOclient::send(socketIOmessageType_t type, uint8_t * payload, size_t length, bool headerToPayload) {
+    bool ret = false;
+    if(length == 0) {
+        length = strlen((const char *)payload);
+    }
+    if(clientIsConnected(&_client)) {
+        if(!headerToPayload) {
+            // webSocket Header
+            ret = WebSocketsClient::sendFrameHeader(&_client, WSop_text, length + 2, true);
+            // Engine.IO / Socket.IO Header
+            if(ret) {
+                uint8_t buf[3] = { eIOtype_MESSAGE, type, 0x00 };
+                ret            = WebSocketsClient::write(&_client, buf, 2);
+            }
+            if(ret && payload && length > 0) {
+                ret = WebSocketsClient::write(&_client, payload, length);
+            }
+            return ret;
+        } else {
+            // TODO implement
+        }
+    }
+    return false;
+}
+
+bool SocketIOclient::send(socketIOmessageType_t type, const uint8_t * payload, size_t length) {
+    return send(type, (uint8_t *)payload, length);
+}
+
+bool SocketIOclient::send(socketIOmessageType_t type, char * payload, size_t length, bool headerToPayload) {
+    return send(type, (uint8_t *)payload, length, headerToPayload);
+}
+
+bool SocketIOclient::send(socketIOmessageType_t type, const char * payload, size_t length) {
+    return send(type, (uint8_t *)payload, length);
+}
+
+bool SocketIOclient::send(socketIOmessageType_t type, String & payload) {
+    return send(type, (uint8_t *)payload.c_str(), payload.length());
+}
+
+/**
+ * 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
+ */
+bool SocketIOclient::sendEVENT(uint8_t * payload, size_t length, bool headerToPayload) {
+    return send(sIOtype_EVENT, payload, length, headerToPayload);
+}
+
+bool SocketIOclient::sendEVENT(const uint8_t * payload, size_t length) {
+    return sendEVENT((uint8_t *)payload, length);
+}
+
+bool SocketIOclient::sendEVENT(char * payload, size_t length, bool headerToPayload) {
+    return sendEVENT((uint8_t *)payload, length, headerToPayload);
+}
+
+bool SocketIOclient::sendEVENT(const char * payload, size_t length) {
+    return sendEVENT((uint8_t *)payload, length);
+}
+
+bool SocketIOclient::sendEVENT(String & payload) {
+    return sendEVENT((uint8_t *)payload.c_str(), payload.length());
+}
+
+void SocketIOclient::loop(void) {
+    WebSocketsClient::loop();
+    unsigned long t = millis();
+    if((t - _lastConnectionFail) > EIO_HEARTBEAT_INTERVAL) {
+        _lastConnectionFail = t;
+        DEBUG_WEBSOCKETS("[wsIOc] send ping\n");
+        WebSocketsClient::sendTXT(eIOtype_PING);
+    }
+}
+
+void SocketIOclient::handleCbEvent(WStype_t type, uint8_t * payload, size_t length) {
+    switch(type) {
+        case WStype_DISCONNECTED:
+            runIOCbEvent(sIOtype_DISCONNECT, NULL, 0);
+            DEBUG_WEBSOCKETS("[wsIOc] Disconnected!\n");
+            break;
+        case WStype_CONNECTED: {
+            DEBUG_WEBSOCKETS("[wsIOc] Connected to url: %s\n", payload);
+            // send message to server when Connected
+            // Engine.io upgrade confirmation message (required)
+            WebSocketsClient::sendTXT(eIOtype_UPGRADE);
+            runIOCbEvent(sIOtype_CONNECT, payload, length);
+        } break;
+        case WStype_TEXT: {
+            if(length < 1) {
+                break;
+            }
+
+            engineIOmessageType_t eType = (engineIOmessageType_t)payload[0];
+            switch(eType) {
+                case eIOtype_PING:
+                    payload[0] = eIOtype_PONG;
+                    DEBUG_WEBSOCKETS("[wsIOc] get ping send pong (%s)\n", payload);
+                    WebSocketsClient::sendTXT(payload, length, false);
+                    break;
+                case eIOtype_PONG:
+                    DEBUG_WEBSOCKETS("[wsIOc] get pong\n");
+                    break;
+                case eIOtype_MESSAGE: {
+                    if(length < 2) {
+                        break;
+                    }
+                    socketIOmessageType_t ioType = (socketIOmessageType_t)payload[1];
+                    uint8_t * data               = &payload[2];
+                    size_t lData                 = length - 2;
+                    switch(ioType) {
+                        case sIOtype_EVENT:
+                            DEBUG_WEBSOCKETS("[wsIOc] get event (%d): %s\n", lData, data);
+                            break;
+                        case sIOtype_CONNECT:
+                        case sIOtype_DISCONNECT:
+                        case sIOtype_ACK:
+                        case sIOtype_ERROR:
+                        case sIOtype_BINARY_EVENT:
+                        case sIOtype_BINARY_ACK:
+                        default:
+                            DEBUG_WEBSOCKETS("[wsIOc] Socket.IO Message Type %c (%02X) is not implemented\n", ioType, ioType);
+                            DEBUG_WEBSOCKETS("[wsIOc] get text: %s\n", payload);
+                            break;
+                    }
+
+                    runIOCbEvent(ioType, data, lData);
+                } break;
+                case eIOtype_OPEN:
+                case eIOtype_CLOSE:
+                case eIOtype_UPGRADE:
+                case eIOtype_NOOP:
+                default:
+                    DEBUG_WEBSOCKETS("[wsIOc] Engine.IO Message Type %c (%02X) is not implemented\n", eType, eType);
+                    DEBUG_WEBSOCKETS("[wsIOc] get text: %s\n", payload);
+                    break;
+            }
+        } break;
+        case WStype_ERROR:
+        case WStype_BIN:
+        case WStype_FRAGMENT_TEXT_START:
+        case WStype_FRAGMENT_BIN_START:
+        case WStype_FRAGMENT:
+        case WStype_FRAGMENT_FIN:
+        case WStype_PING:
+        case WStype_PONG:
+            break;
+    }
+}

src/SocketIOclient.h

@@ -0,0 +1,86 @@
+/**
+ * SocketIOclient.h
+ *
+ *  Created on: May 12, 2018
+ *      Author: links
+ */
+
+#ifndef SOCKETIOCLIENT_H_
+#define SOCKETIOCLIENT_H_
+
+#include "WebSockets.h"
+
+#define EIO_HEARTBEAT_INTERVAL 20000
+
+#define EIO_MAX_HEADER_SIZE (WEBSOCKETS_MAX_HEADER_SIZE + 1)
+#define SIO_MAX_HEADER_SIZE (EIO_MAX_HEADER_SIZE + 1)
+
+typedef enum {
+    eIOtype_OPEN    = '0',    ///< Sent from the server when a new transport is opened (recheck)
+    eIOtype_CLOSE   = '1',    ///< Request the close of this transport but does not shutdown the connection itself.
+    eIOtype_PING    = '2',    ///< Sent by the client. Server should answer with a pong packet containing the same data
+    eIOtype_PONG    = '3',    ///< Sent by the server to respond to ping packets.
+    eIOtype_MESSAGE = '4',    ///< actual message, client and server should call their callbacks with the data
+    eIOtype_UPGRADE = '5',    ///< Before engine.io switches a transport, it tests, if server and client can communicate over this transport. If this test succeed, the client sends an upgrade packets which requests the server to flush its cache on the old transport and switch to the new transport.
+    eIOtype_NOOP    = '6',    ///< A noop packet. Used primarily to force a poll cycle when an incoming websocket connection is received.
+} engineIOmessageType_t;
+
+typedef enum {
+    sIOtype_CONNECT      = '0',
+    sIOtype_DISCONNECT   = '1',
+    sIOtype_EVENT        = '2',
+    sIOtype_ACK          = '3',
+    sIOtype_ERROR        = '4',
+    sIOtype_BINARY_EVENT = '5',
+    sIOtype_BINARY_ACK   = '6',
+} socketIOmessageType_t;
+
+class SocketIOclient : protected WebSocketsClient {
+  public:
+#ifdef __AVR__
+    typedef void (*SocketIOclientEvent)(socketIOmessageType_t type, uint8_t * payload, size_t length);
+#else
+    typedef std::function<void(socketIOmessageType_t type, uint8_t * payload, size_t length)> SocketIOclientEvent;
+#endif
+
+    SocketIOclient(void);
+    virtual ~SocketIOclient(void);
+
+    void begin(const char * host, uint16_t port, const char * url = "/socket.io/?EIO=3", const char * protocol = "arduino");
+    void begin(String host, uint16_t port, String url = "/socket.io/?EIO=3", String protocol = "arduino");
+
+    bool isConnected(void);
+
+    void onEvent(SocketIOclientEvent cbEvent);
+
+    bool sendEVENT(uint8_t * payload, size_t length = 0, bool headerToPayload = false);
+    bool sendEVENT(const uint8_t * payload, size_t length = 0);
+    bool sendEVENT(char * payload, size_t length = 0, bool headerToPayload = false);
+    bool sendEVENT(const char * payload, size_t length = 0);
+    bool sendEVENT(String & payload);
+
+    bool send(socketIOmessageType_t type, uint8_t * payload, size_t length = 0, bool headerToPayload = false);
+    bool send(socketIOmessageType_t type, const uint8_t * payload, size_t length = 0);
+    bool send(socketIOmessageType_t type, char * payload, size_t length = 0, bool headerToPayload = false);
+    bool send(socketIOmessageType_t type, const char * payload, size_t length = 0);
+    bool send(socketIOmessageType_t type, String & payload);
+
+    void loop(void);
+
+  protected:
+    uint64_t _lastHeartbeat = 0;
+    SocketIOclientEvent _cbEvent;
+    virtual void runIOCbEvent(socketIOmessageType_t type, uint8_t * payload, size_t length) {
+        if(_cbEvent) {
+            _cbEvent(type, payload, length);
+        }
+    }
+
+    // Handeling events from websocket layer
+    virtual void runCbEvent(WStype_t type, uint8_t * payload, size_t length) {
+        handleCbEvent(type, payload, length);
+    }
+    void handleCbEvent(WStype_t type, uint8_t * payload, size_t length);
+};
+
+#endif /* SOCKETIOCLIENT_H_ */

src/WebSockets.cpp

@@ -39,7 +39,14 @@ extern "C" {
 #ifdef ESP8266
 #include <Hash.h>
 #elif defined(ESP32)
+#include <esp_system.h>
+
+#if ESP_IDF_VERSION_MAJOR >= 4
+#include <esp32/sha.h>
+#else
 #include <hwcrypto/sha.h>
+#endif
+
 #else
 
 extern "C" {
@@ -48,7 +55,6 @@ extern "C" {
 
 #endif
 
-
 /**
  *
  * @param client WSclient_t *  ptr to the client struct
@@ -60,7 +66,7 @@ void WebSockets::clientDisconnect(WSclient_t * client, uint16_t code, char * rea
     DEBUG_WEBSOCKETS("[WS][%d][handleWebsocket] clientDisconnect code: %u\n", client->num, code);
     if(client->status == WSC_CONNECTED && code) {
         if(reason) {
-            sendFrame(client, WSop_close, (uint8_t *) reason, reasonLen);
+            sendFrame(client, WSop_close, (uint8_t *)reason, reasonLen);
         } else {
             uint8_t buffer[2];
             buffer[0] = ((code >> 8) & 0xFF);
@@ -73,43 +79,15 @@ void WebSockets::clientDisconnect(WSclient_t * client, uint16_t code, char * rea
 
 /**
  *
- * @param client WSclient_t *   ptr to the client struct
+ * @param buf uint8_t *         ptr to the buffer for writing
  * @param opcode WSopcode_t
- * @param payload uint8_t *     ptr to the payload
  * @param length size_t         length of the payload
  * @param mask bool             add dummy mask to the frame (needed for web browser)
+ * @param maskkey uint8_t[4]    key used for payload
  * @param fin bool              can be used to send data in more then one frame (set fin on the last frame)
- * @param headerToPayload bool  set true if the payload has reserved 14 Byte at the beginning to dynamically add the Header (payload neet to be in RAM!)
- * @return true if ok
  */
-bool WebSockets::sendFrame(WSclient_t * client, WSopcode_t opcode, uint8_t * payload, size_t length, bool mask, bool fin, bool headerToPayload) {
-
-    if(client->tcp && !client->tcp->connected()) {
-        DEBUG_WEBSOCKETS("[WS][%d][sendFrame] not Connected!?\n", client->num);
-        return false;
-    }
-
-    if(client->status != WSC_CONNECTED) {
-        DEBUG_WEBSOCKETS("[WS][%d][sendFrame] not in WSC_CONNECTED state!?\n", client->num);
-        return false;
-    }
-
-    DEBUG_WEBSOCKETS("[WS][%d][sendFrame] ------- send message frame -------\n", client->num);
-    DEBUG_WEBSOCKETS("[WS][%d][sendFrame] fin: %u opCode: %u mask: %u length: %u headerToPayload: %u\n", client->num, fin, opcode, mask, length, headerToPayload);
-
-    if(opcode == WSop_text) {
-        DEBUG_WEBSOCKETS("[WS][%d][sendFrame] text: %s\n", client->num, (payload + (headerToPayload ? 14 : 0)));
-    }
-
-    uint8_t maskKey[4] = { 0x00, 0x00, 0x00, 0x00 };
-    uint8_t buffer[WEBSOCKETS_MAX_HEADER_SIZE] = { 0 };
-
+uint8_t WebSockets::createHeader(uint8_t * headerPtr, WSopcode_t opcode, size_t length, bool mask, uint8_t maskKey[4], bool fin) {
     uint8_t headerSize;
-    uint8_t * headerPtr;
-    uint8_t * payloadPtr = payload;
-    bool useInternBuffer = false;
-    bool ret = true;
-
     // calculate header Size
     if(length < 126) {
         headerSize = 2;
@@ -123,29 +101,6 @@ bool WebSockets::sendFrame(WSclient_t * client, WSopcode_t opcode, uint8_t * pay
         headerSize += 4;
     }
 
-#ifdef WEBSOCKETS_USE_BIG_MEM
-    // only for ESP since AVR has less HEAP
-    // try to send data in one TCP package (only if some free Heap is there)
-    if(!headerToPayload && ((length > 0) && (length < 1400)) && (GET_FREE_HEAP > 6000)) {
-        DEBUG_WEBSOCKETS("[WS][%d][sendFrame] pack to one TCP package...\n", client->num);
-        uint8_t * dataPtr = (uint8_t *) malloc(length + WEBSOCKETS_MAX_HEADER_SIZE);
-        if(dataPtr) {
-            memcpy((dataPtr + WEBSOCKETS_MAX_HEADER_SIZE), payload, length);
-            headerToPayload = true;
-            useInternBuffer = true;
-            payloadPtr = dataPtr;
-        }
-    }
-#endif
-
-    // set Header Pointer
-    if(headerToPayload) {
-        // calculate offset in payload
-        headerPtr = (payloadPtr + (WEBSOCKETS_MAX_HEADER_SIZE - headerSize));
-    } else {
-        headerPtr = &buffer[0];
-    }
-
     // create header
 
     // byte 0
@@ -153,7 +108,7 @@ bool WebSockets::sendFrame(WSclient_t * client, WSopcode_t opcode, uint8_t * pay
     if(fin) {
         *headerPtr |= bit(7);    ///< set Fin
     }
-    *headerPtr |= opcode;        ///< set opcode
+    *headerPtr |= opcode;    ///< set opcode
     headerPtr++;
 
     // byte 1
@@ -195,36 +150,133 @@ bool WebSockets::sendFrame(WSclient_t * client, WSopcode_t opcode, uint8_t * pay
     }
 
     if(mask) {
-        if(useInternBuffer) {
-            // if we use a Intern Buffer we can modify the data
-            // 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[0];
+        headerPtr++;
+        *headerPtr = maskKey[1];
+        headerPtr++;
+        *headerPtr = maskKey[2];
+        headerPtr++;
+        *headerPtr = maskKey[3];
+        headerPtr++;
+    }
+    return headerSize;
+}
 
-            uint8_t * dataMaskPtr;
+/**
+ *
+ * @param client WSclient_t *   ptr to the client struct
+ * @param opcode WSopcode_t
+ * @param length size_t         length of the payload
+ * @param fin bool              can be used to send data in more then one frame (set fin on the last frame)
+ * @return true if ok
+ */
+bool WebSockets::sendFrameHeader(WSclient_t * client, WSopcode_t opcode, size_t length, bool fin) {
+    uint8_t maskKey[4]                         = { 0x00, 0x00, 0x00, 0x00 };
+    uint8_t buffer[WEBSOCKETS_MAX_HEADER_SIZE] = { 0 };
 
-            if(headerToPayload) {
-                dataMaskPtr = (payloadPtr + WEBSOCKETS_MAX_HEADER_SIZE);
-            } else {
-                dataMaskPtr = payloadPtr;
-            }
+    uint8_t headerSize = createHeader(&buffer[0], opcode, length, client->cIsClient, maskKey, fin);
 
-            for(size_t x = 0; x < length; x++) {
-                dataMaskPtr[x] = (dataMaskPtr[x] ^ maskKey[x % 4]);
-            }
+    if(write(client, &buffer[0], headerSize) != headerSize) {
+        return false;
+    }
 
+    return true;
+}
+
+/**
+ *
+ * @param client WSclient_t *   ptr to the client struct
+ * @param opcode WSopcode_t
+ * @param payload uint8_t *     ptr to the payload
+ * @param length size_t         length of the payload
+ * @param fin bool              can be used to send data in more then one frame (set fin on the last frame)
+ * @param headerToPayload bool  set true if the payload has reserved 14 Byte at the beginning to dynamically add the Header (payload neet to be in RAM!)
+ * @return true if ok
+ */
+bool WebSockets::sendFrame(WSclient_t * client, WSopcode_t opcode, uint8_t * payload, size_t length, bool fin, bool headerToPayload) {
+    if(client->tcp && !client->tcp->connected()) {
+        DEBUG_WEBSOCKETS("[WS][%d][sendFrame] not Connected!?\n", client->num);
+        return false;
+    }
+
+    if(client->status != WSC_CONNECTED) {
+        DEBUG_WEBSOCKETS("[WS][%d][sendFrame] not in WSC_CONNECTED state!?\n", client->num);
+        return false;
+    }
+
+    DEBUG_WEBSOCKETS("[WS][%d][sendFrame] ------- send message frame -------\n", client->num);
+    DEBUG_WEBSOCKETS("[WS][%d][sendFrame] fin: %u opCode: %u mask: %u length: %u headerToPayload: %u\n", client->num, fin, opcode, client->cIsClient, length, headerToPayload);
+
+    if(opcode == WSop_text) {
+        DEBUG_WEBSOCKETS("[WS][%d][sendFrame] text: %s\n", client->num, (payload + (headerToPayload ? 14 : 0)));
+    }
+
+    uint8_t maskKey[4]                         = { 0x00, 0x00, 0x00, 0x00 };
+    uint8_t buffer[WEBSOCKETS_MAX_HEADER_SIZE] = { 0 };
+
+    uint8_t headerSize;
+    uint8_t * headerPtr;
+    uint8_t * payloadPtr = payload;
+    bool useInternBuffer = false;
+    bool ret             = true;
+
+    // calculate header Size
+    if(length < 126) {
+        headerSize = 2;
+    } else if(length < 0xFFFF) {
+        headerSize = 4;
+    } else {
+        headerSize = 10;
+    }
+
+    if(client->cIsClient) {
+        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)
+    if(!headerToPayload && ((length > 0) && (length < 1400)) && (GET_FREE_HEAP > 6000)) {
+        DEBUG_WEBSOCKETS("[WS][%d][sendFrame] pack to one TCP package...\n", client->num);
+        uint8_t * dataPtr = (uint8_t *)malloc(length + WEBSOCKETS_MAX_HEADER_SIZE);
+        if(dataPtr) {
+            memcpy((dataPtr + WEBSOCKETS_MAX_HEADER_SIZE), payload, length);
+            headerToPayload = true;
+            useInternBuffer = true;
+            payloadPtr      = dataPtr;
+        }
+    }
+#endif
+
+    // set Header Pointer
+    if(headerToPayload) {
+        // calculate offset in payload
+        headerPtr = (payloadPtr + (WEBSOCKETS_MAX_HEADER_SIZE - headerSize));
+    } else {
+        headerPtr = &buffer[0];
+    }
+
+    if(client->cIsClient && useInternBuffer) {
+        // if we use a Intern Buffer we can modify the data
+        // by this fact its possible the do the masking
+        for(uint8_t x = 0; x < sizeof(maskKey); x++) {
+            maskKey[x] = random(0xFF);
+        }
+    }
+
+    createHeader(headerPtr, opcode, length, client->cIsClient, maskKey, fin);
+
+    if(client->cIsClient && useInternBuffer) {
+        uint8_t * dataMaskPtr;
+
+        if(headerToPayload) {
+            dataMaskPtr = (payloadPtr + WEBSOCKETS_MAX_HEADER_SIZE);
         } else {
-            *headerPtr = maskKey[0];
-            headerPtr++;
-            *headerPtr = maskKey[1];
-            headerPtr++;
-            *headerPtr = maskKey[2];
-            headerPtr++;
-            *headerPtr = maskKey[3];
-            headerPtr++;
+            dataMaskPtr = payloadPtr;
+        }
+
+        for(size_t x = 0; x < length; x++) {
+            dataMaskPtr[x] = (dataMaskPtr[x] ^ maskKey[x % 4]);
         }
     }
 
@@ -269,10 +321,10 @@ bool WebSockets::sendFrame(WSclient_t * client, WSopcode_t opcode, uint8_t * pay
  * @param client WSclient_t *  ptr to the client struct
  */
 void WebSockets::headerDone(WSclient_t * client) {
-    client->status = WSC_CONNECTED;
+    client->status    = WSC_CONNECTED;
     client->cWsRXsize = 0;
     DEBUG_WEBSOCKETS("[WS][%d][headerDone] Header Handling Done.\n", client->num);
-#if (WEBSOCKETS_NETWORK_TYPE == NETWORK_ESP8266_ASYNC)
+#if(WEBSOCKETS_NETWORK_TYPE == NETWORK_ESP8266_ASYNC)
     client->cHttpLine = "";
     handleWebsocket(client);
 #endif
@@ -319,12 +371,12 @@ bool WebSockets::handleWebsocketWaitFor(WSclient_t * client, size_t size) {
             // timeout or error
             server->clientDisconnect(client, 1002);
         }
-    }, this, size, std::placeholders::_1, std::placeholders::_2));
+    },
+                                                                                          this, size, std::placeholders::_1, std::placeholders::_2));
     return false;
 }
 
 void WebSockets::handleWebsocketCb(WSclient_t * client) {
-
     if(!client->tcp || !client->tcp->connected()) {
         return;
     }
@@ -332,7 +384,7 @@ void WebSockets::handleWebsocketCb(WSclient_t * client) {
     uint8_t * buffer = client->cWsHeader;
 
     WSMessageHeader_t * header = &client->cWsHeaderDecode;
-    uint8_t * payload = NULL;
+    uint8_t * payload          = NULL;
 
     uint8_t headerLen = 2;
 
@@ -341,15 +393,15 @@ void WebSockets::handleWebsocketCb(WSclient_t * client) {
     }
 
     // split first 2 bytes in the data
-    header->fin = ((*buffer >> 7) & 0x01);
-    header->rsv1 = ((*buffer >> 6) & 0x01);
-    header->rsv2 = ((*buffer >> 5) & 0x01);
-    header->rsv3 = ((*buffer >> 4) & 0x01);
-    header->opCode = (WSopcode_t) (*buffer & 0x0F);
+    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++;
 
-    header->mask = ((*buffer >> 7) & 0x01);
-    header->payloadLen = (WSopcode_t) (*buffer & 0x7F);
+    header->mask       = ((*buffer >> 7) & 0x01);
+    header->payloadLen = (WSopcode_t)(*buffer & 0x7F);
     buffer++;
 
     if(header->payloadLen == 126) {
@@ -396,7 +448,7 @@ void WebSockets::handleWebsocketCb(WSclient_t * client) {
 
     if(header->payloadLen > 0) {
         // if text data we need one more
-        payload = (uint8_t *) malloc(header->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, header->payloadLen);
@@ -410,7 +462,6 @@ void WebSockets::handleWebsocketCb(WSclient_t * client) {
 }
 
 void WebSockets::handleWebsocketPayloadCb(WSclient_t * client, bool ok, uint8_t * payload) {
-
     WSMessageHeader_t * header = &client->cWsHeaderDecode;
     if(ok) {
         if(header->payloadLen > 0) {
@@ -434,18 +485,22 @@ void WebSockets::handleWebsocketPayloadCb(WSclient_t * client, bool ok, uint8_t
                 break;
             case WSop_ping:
                 // send pong back
-                sendFrame(client, WSop_pong, payload, header->payloadLen, true);
+                DEBUG_WEBSOCKETS("[WS][%d][handleWebsocket] ping received (%s)\n", client->num, payload ? (const char *)payload : "");
+                sendFrame(client, WSop_pong, payload, header->payloadLen);
+                messageReceived(client, header->opCode, payload, header->payloadLen, header->fin);
                 break;
             case WSop_pong:
-                DEBUG_WEBSOCKETS("[WS][%d][handleWebsocket] get pong (%s)\n", client->num, payload ? (const char*)payload : "");
+                DEBUG_WEBSOCKETS("[WS][%d][handleWebsocket] get pong (%s)\n", client->num, payload ? (const char *)payload : "");
+                client->pongReceived = true;
+                messageReceived(client, header->opCode, payload, header->payloadLen, header->fin);
                 break;
             case WSop_close: {
-                #ifndef NODEBUG_WEBSOCKETS
-                    uint16_t reasonCode = 1000;
-                    if(header->payloadLen >= 2) {
-                        reasonCode = payload[0] << 8 | payload[1];
-                    }
-                #endif
+#ifndef NODEBUG_WEBSOCKETS
+                uint16_t reasonCode = 1000;
+                if(header->payloadLen >= 2) {
+                    reasonCode = payload[0] << 8 | payload[1];
+                }
+#endif
                 DEBUG_WEBSOCKETS("[WS][%d][handleWebsocket] get ask for close. Code: %d", client->num, reasonCode);
                 if(header->payloadLen > 2) {
                     DEBUG_WEBSOCKETS(" (%s)\n", (payload + 2));
@@ -453,8 +508,7 @@ void WebSockets::handleWebsocketPayloadCb(WSclient_t * client, bool ok, uint8_t
                     DEBUG_WEBSOCKETS("\n");
                 }
                 clientDisconnect(client, 1000);
-            }
-            	break;
+            } break;
             default:
                 clientDisconnect(client, 1002);
                 break;
@@ -466,7 +520,7 @@ void WebSockets::handleWebsocketPayloadCb(WSclient_t * client, bool ok, uint8_t
 
         // reset input
         client->cWsRXsize = 0;
-#if (WEBSOCKETS_NETWORK_TYPE == NETWORK_ESP8266_ASYNC)
+#if(WEBSOCKETS_NETWORK_TYPE == NETWORK_ESP8266_ASYNC)
         //register callback for next message
         handleWebsocketWaitFor(client, 2);
 #endif
@@ -489,12 +543,12 @@ String WebSockets::acceptKey(String & clientKey) {
     sha1(clientKey + "258EAFA5-E914-47DA-95CA-C5AB0DC85B11", &sha1HashBin[0]);
 #elif defined(ESP32)
     String data = clientKey + "258EAFA5-E914-47DA-95CA-C5AB0DC85B11";
-    esp_sha(SHA1, (unsigned char*)data.c_str(), data.length(), &sha1HashBin[0]);
+    esp_sha(SHA1, (unsigned char *)data.c_str(), data.length(), &sha1HashBin[0]);
 #else
     clientKey += "258EAFA5-E914-47DA-95CA-C5AB0DC85B11";
     SHA1_CTX ctx;
     SHA1Init(&ctx);
-    SHA1Update(&ctx, (const unsigned char*)clientKey.c_str(), clientKey.length());
+    SHA1Update(&ctx, (const unsigned char *)clientKey.c_str(), clientKey.length());
     SHA1Final(&sha1HashBin[0], &ctx);
 #endif
 
@@ -511,13 +565,13 @@ 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);
-    char * buffer = (char *) malloc(size);
+    size_t size   = ((length * 1.6f) + 1);
+    char * buffer = (char *)malloc(size);
     if(buffer) {
         base64_encodestate _state;
         base64_init_encodestate(&_state);
-        int len = base64_encode_block((const char *) &data[0], length, &buffer[0], &_state);
-        len = base64_encode_blockend((buffer + len), &_state);
+        int len = base64_encode_block((const char *)&data[0], length, &buffer[0], &_state);
+        len     = base64_encode_blockend((buffer + len), &_state);
 
         String base64 = String(buffer);
         free(buffer);
@@ -534,7 +588,7 @@ String WebSockets::base64_encode(uint8_t * data, size_t length) {
  * @return true if ok
  */
 bool WebSockets::readCb(WSclient_t * client, uint8_t * out, size_t n, WSreadWaitCb cb) {
-#if (WEBSOCKETS_NETWORK_TYPE == NETWORK_ESP8266_ASYNC)
+#if(WEBSOCKETS_NETWORK_TYPE == NETWORK_ESP8266_ASYNC)
     if(!client->tcp || !client->tcp->connected()) {
         return false;
     }
@@ -543,11 +597,12 @@ bool WebSockets::readCb(WSclient_t * client, uint8_t * out, size_t n, WSreadWait
         if(cb) {
             cb(client, ok);
         }
-    }, client, std::placeholders::_1, cb));
+    },
+                                       client, std::placeholders::_1, cb));
 
 #else
     unsigned long t = millis();
-    size_t len;
+    ssize_t len;
     DEBUG_WEBSOCKETS("[readCb] n: %zu t: %lu\n", n, t);
     while(n > 0) {
         if(client->tcp == NULL) {
@@ -575,14 +630,12 @@ bool WebSockets::readCb(WSclient_t * client, uint8_t * out, size_t n, WSreadWait
         }
 
         if(!client->tcp->available()) {
-#if (WEBSOCKETS_NETWORK_TYPE == NETWORK_ESP8266)
-            delay(0);
-#endif
+            WEBSOCKETS_YIELD();
             continue;
         }
 
-        len = client->tcp->read((uint8_t*) out, n);
-        if(len) {
+        len = client->tcp->read((uint8_t *)out, n);
+        if(len > 0) {
             t = millis();
             out += len;
             n -= len;
@@ -590,13 +643,12 @@ bool WebSockets::readCb(WSclient_t * client, uint8_t * out, size_t n, WSreadWait
         } else {
             //DEBUG_WEBSOCKETS("Receive %d left %d!\n", len, n);
         }
-#if (WEBSOCKETS_NETWORK_TYPE == NETWORK_ESP8266)
-        delay(0);
-#endif
+        WEBSOCKETS_YIELD();
     }
     if(cb) {
         cb(client, true);
     }
+    WEBSOCKETS_YIELD();
 #endif
     return true;
 }
@@ -608,48 +660,93 @@ bool WebSockets::readCb(WSclient_t * client, uint8_t * out, size_t n, WSreadWait
  * @param n size_t byte count
  * @return bytes send
  */
-size_t WebSockets::write(WSclient_t * client, uint8_t *out, size_t n) {
-	if(out == NULL) return 0;
-	if(client == NULL) return 0;
-	unsigned long t = millis();
-	size_t len = 0;
-	size_t total = 0;
-	DEBUG_WEBSOCKETS("[write] n: %zu t: %lu\n", n, t);
-	while(n > 0) {
-		if(client->tcp == NULL) {
-			DEBUG_WEBSOCKETS("[write] tcp is null!\n");
-			break;
-		}
+size_t WebSockets::write(WSclient_t * client, uint8_t * out, size_t n) {
+    if(out == NULL)
+        return 0;
+    if(client == NULL)
+        return 0;
+    unsigned long t = millis();
+    size_t len      = 0;
+    size_t total    = 0;
+    DEBUG_WEBSOCKETS("[write] n: %zu t: %lu\n", n, t);
+    while(n > 0) {
+        if(client->tcp == NULL) {
+            DEBUG_WEBSOCKETS("[write] tcp is null!\n");
+            break;
+        }
 
-		if(!client->tcp->connected()) {
-			DEBUG_WEBSOCKETS("[write] not connected!\n");
-			break;
-		}
+        if(!client->tcp->connected()) {
+            DEBUG_WEBSOCKETS("[write] not connected!\n");
+            break;
+        }
 
-		if((millis() - t) > WEBSOCKETS_TCP_TIMEOUT) {
-			DEBUG_WEBSOCKETS("[write] write TIMEOUT! %lu\n", (millis() - t));
-			break;
-		}
+        if((millis() - t) > WEBSOCKETS_TCP_TIMEOUT) {
+            DEBUG_WEBSOCKETS("[write] write TIMEOUT! %lu\n", (millis() - t));
+            break;
+        }
 
-		len = client->tcp->write((const uint8_t*)out, n);
-		if(len) {
-			t = millis();
-			out += len;
-			n -= len;
-			total += len;
-			//DEBUG_WEBSOCKETS("write %d left %d!\n", len, n);
-		} else {
-			//DEBUG_WEBSOCKETS("write %d failed left %d!\n", len, n);
-		}
-#if (WEBSOCKETS_NETWORK_TYPE == NETWORK_ESP8266)
-		delay(0);
-#endif
-	}
-	return total;
+        len = client->tcp->write((const uint8_t *)out, n);
+        if(len) {
+            t = millis();
+            out += len;
+            n -= len;
+            total += len;
+            //DEBUG_WEBSOCKETS("write %d left %d!\n", len, n);
+        } else {
+            //DEBUG_WEBSOCKETS("write %d failed left %d!\n", len, n);
+        }
+        WEBSOCKETS_YIELD();
+    }
+    WEBSOCKETS_YIELD();
+    return total;
 }
 
-size_t WebSockets::write(WSclient_t * client, const char *out) {
-	if(client == NULL) return 0;
-	if(out == NULL) return 0;
-	return write(client, (uint8_t*)out, strlen(out));
+size_t WebSockets::write(WSclient_t * client, const char * out) {
+    if(client == NULL)
+        return 0;
+    if(out == NULL)
+        return 0;
+    return write(client, (uint8_t *)out, strlen(out));
+}
+
+/**
+ * enable ping/pong heartbeat process
+ * @param client WSclient_t *
+ * @param pingInterval uint32_t how often ping will be sent
+ * @param pongTimeout uint32_t millis after which pong should timout if not received
+ * @param disconnectTimeoutCount uint8_t how many timeouts before disconnect, 0=> do not disconnect
+ */
+void WebSockets::enableHeartbeat(WSclient_t * client, uint32_t pingInterval, uint32_t pongTimeout, uint8_t disconnectTimeoutCount) {
+    if(client == NULL)
+        return;
+    client->pingInterval           = pingInterval;
+    client->pongTimeout            = pongTimeout;
+    client->disconnectTimeoutCount = disconnectTimeoutCount;
+    client->pongReceived           = false;
+}
+
+/**
+ * handle ping/pong heartbeat timeout process
+ * @param client WSclient_t *
+ */
+void WebSockets::handleHBTimeout(WSclient_t * client) {
+    if(client->pingInterval) {    // if heartbeat is enabled
+        uint32_t pi = millis() - client->lastPing;
+
+        if(client->pongReceived) {
+            client->pongTimeoutCount = 0;
+        } else {
+            if(pi > client->pongTimeout) {    // pong not received in time
+                client->pongTimeoutCount++;
+                client->lastPing = millis() - client->pingInterval - 500;    // force ping on the next run
+
+                DEBUG_WEBSOCKETS("[HBtimeout] pong TIMEOUT! lp=%d millis=%d pi=%d count=%d\n", client->lastPing, millis(), pi, client->pongTimeoutCount);
+
+                if(client->disconnectTimeoutCount && client->pongTimeoutCount >= client->disconnectTimeoutCount) {
+                    DEBUG_WEBSOCKETS("[HBtimeout] count=%d, DISCONNECTING\n", client->pongTimeoutCount);
+                    clientDisconnect(client);
+                }
+            }
+        }
+    }
 }

src/WebSockets.h

@@ -27,7 +27,7 @@
 
 #ifdef STM32_DEVICE
 #include <application.h>
-#define bit(b) (1UL << (b)) // Taken directly from Arduino.h
+#define bit(b) (1UL << (b))    // Taken directly from Arduino.h
 #else
 #include <Arduino.h>
 #include <IPAddress.h>
@@ -40,16 +40,14 @@
 #include <functional>
 #endif
 
-
 #ifndef NODEBUG_WEBSOCKETS
 #ifdef DEBUG_ESP_PORT
-#define DEBUG_WEBSOCKETS(...) DEBUG_ESP_PORT.printf( __VA_ARGS__ )
+#define DEBUG_WEBSOCKETS(...) DEBUG_ESP_PORT.printf(__VA_ARGS__)
 #else
 //#define DEBUG_WEBSOCKETS(...) os_printf( __VA_ARGS__ )
 #endif
 #endif
 
-
 #ifndef DEBUG_WEBSOCKETS
 #define DEBUG_WEBSOCKETS(...)
 #define NODEBUG_WEBSOCKETS
@@ -57,38 +55,46 @@
 
 #if defined(ESP8266) || defined(ESP32)
 
-#define WEBSOCKETS_MAX_DATA_SIZE  (15*1024)
+#define WEBSOCKETS_MAX_DATA_SIZE (15 * 1024)
 #define WEBSOCKETS_USE_BIG_MEM
 #define GET_FREE_HEAP ESP.getFreeHeap()
 // moves all Header strings to Flash (~300 Byte)
 //#define WEBSOCKETS_SAVE_RAM
 
+#if defined(ESP8266)
+#define WEBSOCKETS_YIELD() delay(0)
+#elif defined(ESP32)
+#define WEBSOCKETS_YIELD() yield()
+#endif
+
 #elif defined(STM32_DEVICE)
 
-#define WEBSOCKETS_MAX_DATA_SIZE  (15*1024)
+#define WEBSOCKETS_MAX_DATA_SIZE (15 * 1024)
 #define WEBSOCKETS_USE_BIG_MEM
 #define GET_FREE_HEAP System.freeMemory()
+#define WEBSOCKETS_YIELD()
 
 #else
 
 //atmega328p has only 2KB ram!
-#define WEBSOCKETS_MAX_DATA_SIZE  (1024)
+#define WEBSOCKETS_MAX_DATA_SIZE (1024)
 // moves all Header strings to Flash
 #define WEBSOCKETS_SAVE_RAM
+#define WEBSOCKETS_YIELD()
 
 #endif
 
+#define WEBSOCKETS_TCP_TIMEOUT (5000)
 
-#define WEBSOCKETS_TCP_TIMEOUT    (2000)
-
-#define NETWORK_ESP8266_ASYNC   (0)
-#define NETWORK_ESP8266         (1)
-#define NETWORK_W5100           (2)
-#define NETWORK_ENC28J60        (3)
-#define NETWORK_ESP32           (4)
+#define NETWORK_ESP8266_ASYNC (0)
+#define NETWORK_ESP8266 (1)
+#define NETWORK_W5100 (2)
+#define NETWORK_ENC28J60 (3)
+#define NETWORK_ESP32 (4)
+#define NETWORK_ESP32_ETH (5)
 
 // max size of the WS Message Header
-#define WEBSOCKETS_MAX_HEADER_SIZE  (14)
+#define WEBSOCKETS_MAX_HEADER_SIZE (14)
 
 #if !defined(WEBSOCKETS_NETWORK_TYPE)
 // select Network type based
@@ -99,7 +105,7 @@
 
 #elif defined(ESP32)
 #define WEBSOCKETS_NETWORK_TYPE NETWORK_ESP32
-
+//#define WEBSOCKETS_NETWORK_TYPE NETWORK_ESP32_ETH
 #else
 #define WEBSOCKETS_NETWORK_TYPE NETWORK_W5100
 
@@ -107,13 +113,12 @@
 #endif
 
 // Includes and defined based on Network Type
-#if (WEBSOCKETS_NETWORK_TYPE == NETWORK_ESP8266_ASYNC)
+#if(WEBSOCKETS_NETWORK_TYPE == NETWORK_ESP8266_ASYNC)
 
 // Note:
 //   No SSL/WSS support for client in Async mode
 //   TLS lib need a sync interface!
 
-
 #if defined(ESP8266)
 #include <ESP8266WiFi.h>
 #elif defined(ESP32)
@@ -130,7 +135,7 @@
 #define WEBSOCKETS_NETWORK_CLASS AsyncTCPbuffer
 #define WEBSOCKETS_NETWORK_SERVER_CLASS AsyncServer
 
-#elif (WEBSOCKETS_NETWORK_TYPE == NETWORK_ESP8266)
+#elif(WEBSOCKETS_NETWORK_TYPE == NETWORK_ESP8266)
 
 #if !defined(ESP8266) && !defined(ESP31B)
 #error "network type ESP8266 only possible on the ESP mcu!"
@@ -142,9 +147,10 @@
 #include <ESP31BWiFi.h>
 #endif
 #define WEBSOCKETS_NETWORK_CLASS WiFiClient
+#define WEBSOCKETS_NETWORK_SSL_CLASS WiFiClientSecure
 #define WEBSOCKETS_NETWORK_SERVER_CLASS WiFiServer
 
-#elif (WEBSOCKETS_NETWORK_TYPE == NETWORK_W5100)
+#elif(WEBSOCKETS_NETWORK_TYPE == NETWORK_W5100)
 
 #ifdef STM32_DEVICE
 #define WEBSOCKETS_NETWORK_CLASS TCPClient
@@ -156,28 +162,39 @@
 #define WEBSOCKETS_NETWORK_SERVER_CLASS EthernetServer
 #endif
 
-#elif (WEBSOCKETS_NETWORK_TYPE == NETWORK_ENC28J60)
+#elif(WEBSOCKETS_NETWORK_TYPE == NETWORK_ENC28J60)
 
 #include <UIPEthernet.h>
 #define WEBSOCKETS_NETWORK_CLASS UIPClient
 #define WEBSOCKETS_NETWORK_SERVER_CLASS UIPServer
 
-#elif (WEBSOCKETS_NETWORK_TYPE == NETWORK_ESP32)
+#elif(WEBSOCKETS_NETWORK_TYPE == NETWORK_ESP32)
 
 #include <WiFi.h>
 #include <WiFiClientSecure.h>
 #define WEBSOCKETS_NETWORK_CLASS WiFiClient
+#define WEBSOCKETS_NETWORK_SSL_CLASS WiFiClientSecure
+#define WEBSOCKETS_NETWORK_SERVER_CLASS WiFiServer
+
+#elif(WEBSOCKETS_NETWORK_TYPE == NETWORK_ESP32_ETH)
+
+#include <ETH.h>
+#define WEBSOCKETS_NETWORK_CLASS WiFiClient
 #define WEBSOCKETS_NETWORK_SERVER_CLASS WiFiServer
 
 #else
 #error "no network type selected!"
 #endif
 
+#ifdef WEBSOCKETS_NETWORK_SSL_CLASS
+#define HAS_SSL
+#endif
+
 // moves all Header strings to Flash (~300 Byte)
 #ifdef WEBSOCKETS_SAVE_RAM
-#define WEBSOCKETS_STRING(var)  F(var)
+#define WEBSOCKETS_STRING(var) F(var)
 #else
-#define WEBSOCKETS_STRING(var)  var
+#define WEBSOCKETS_STRING(var) var
 #endif
 
 typedef enum {
@@ -192,117 +209,128 @@ typedef enum {
     WStype_CONNECTED,
     WStype_TEXT,
     WStype_BIN,
-	WStype_FRAGMENT_TEXT_START,
-	WStype_FRAGMENT_BIN_START,
-	WStype_FRAGMENT,
-	WStype_FRAGMENT_FIN,
+    WStype_FRAGMENT_TEXT_START,
+    WStype_FRAGMENT_BIN_START,
+    WStype_FRAGMENT,
+    WStype_FRAGMENT_FIN,
+    WStype_PING,
+    WStype_PONG,
 } WStype_t;
 
 typedef enum {
-    WSop_continuation = 0x00, ///< %x0 denotes a continuation frame
-    WSop_text = 0x01,         ///< %x1 denotes a text frame
-    WSop_binary = 0x02,       ///< %x2 denotes a binary frame
-                              ///< %x3-7 are reserved for further non-control frames
-    WSop_close = 0x08,        ///< %x8 denotes a connection close
-    WSop_ping = 0x09,         ///< %x9 denotes a ping
-    WSop_pong = 0x0A          ///< %xA denotes a pong
-                              ///< %xB-F are reserved for further control frames
+    WSop_continuation = 0x00,    ///< %x0 denotes a continuation frame
+    WSop_text         = 0x01,    ///< %x1 denotes a text frame
+    WSop_binary       = 0x02,    ///< %x2 denotes a binary frame
+                                 ///< %x3-7 are reserved for further non-control frames
+    WSop_close = 0x08,           ///< %x8 denotes a connection close
+    WSop_ping  = 0x09,           ///< %x9 denotes a ping
+    WSop_pong  = 0x0A            ///< %xA denotes a pong
+                                 ///< %xB-F are reserved for further control frames
 } WSopcode_t;
 
 typedef struct {
+    bool fin;
+    bool rsv1;
+    bool rsv2;
+    bool rsv3;
 
-        bool fin;
-        bool rsv1;
-        bool rsv2;
-        bool rsv3;
+    WSopcode_t opCode;
+    bool mask;
 
-        WSopcode_t opCode;
-        bool mask;
+    size_t payloadLen;
 
-        size_t payloadLen;
-
-        uint8_t * maskKey;
+    uint8_t * maskKey;
 } WSMessageHeader_t;
 
 typedef struct {
-        uint8_t num; ///< connection number
+    uint8_t num;    ///< connection number
 
-        WSclientsStatus_t status;
+    WSclientsStatus_t status;
 
-        WEBSOCKETS_NETWORK_CLASS * tcp;
+    WEBSOCKETS_NETWORK_CLASS * tcp;
 
-        bool isSocketIO;    ///< client for socket.io server
+    bool isSocketIO;    ///< client for socket.io server
 
-#if (WEBSOCKETS_NETWORK_TYPE == NETWORK_ESP8266) || (WEBSOCKETS_NETWORK_TYPE == NETWORK_ESP32)
-        bool isSSL;             ///< run in ssl mode
-        WiFiClientSecure * ssl;
+#if defined(HAS_SSL)
+    bool isSSL;    ///< run in ssl mode
+    WEBSOCKETS_NETWORK_SSL_CLASS * ssl;
 #endif
 
-        String cUrl;        ///< http url
-        uint16_t cCode;     ///< http code
+    String cUrl;       ///< http url
+    uint16_t cCode;    ///< http code
 
-        bool cIsUpgrade;    ///< Connection == Upgrade
-        bool cIsWebsocket;  ///< Upgrade == websocket
+    bool cIsClient = false;    ///< will be used for masking
+    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
+    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;
+    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
+    String base64Authorization;    ///< Base64 encoded Auth request
+    String plainAuthorization;     ///< Base64 encoded Auth request
 
-        String extraHeaders;
+    String extraHeaders;
 
-        bool cHttpHeadersValid; ///< non-websocket http header validity indicator
-        size_t cMandatoryHeadersCount; ///< non-websocket mandatory http headers present count
+    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
+    bool pongReceived;
+    uint32_t pingInterval;             // how often ping will be sent, 0 means "heartbeat is not active"
+    uint32_t lastPing;                 // millis when last pong has been received
+    uint32_t pongTimeout;              // interval in millis after which pong is considered to timeout
+    uint8_t disconnectTimeoutCount;    // after how many subsequent pong timeouts discconnect will happen, 0 means "do not disconnect"
+    uint8_t pongTimeoutCount;          // current pong timeout count
+
+#if(WEBSOCKETS_NETWORK_TYPE == NETWORK_ESP8266_ASYNC)
+    String cHttpLine;    ///< HTTP header lines
 #endif
 
 } WSclient_t;
 
-
-
 class WebSockets {
-    protected:
+  protected:
 #ifdef __AVR__
-        typedef void (*WSreadWaitCb)(WSclient_t * client, bool ok);
+    typedef void (*WSreadWaitCb)(WSclient_t * client, bool ok);
 #else
-        typedef std::function<void(WSclient_t * client, bool ok)> WSreadWaitCb;
+    typedef std::function<void(WSclient_t * client, bool ok)> WSreadWaitCb;
 #endif
 
-        virtual void clientDisconnect(WSclient_t * client) = 0;
-        virtual bool clientIsConnected(WSclient_t * client) = 0;
+    virtual void clientDisconnect(WSclient_t * client)  = 0;
+    virtual bool clientIsConnected(WSclient_t * client) = 0;
 
-        virtual void messageReceived(WSclient_t * client, WSopcode_t opcode, uint8_t * payload, size_t length, bool fin) = 0;
+    void clientDisconnect(WSclient_t * client, uint16_t code, char * reason = NULL, size_t reasonLen = 0);
 
-        void clientDisconnect(WSclient_t * client, uint16_t code, char * reason = NULL, size_t reasonLen = 0);
-        bool sendFrame(WSclient_t * client, WSopcode_t opcode, uint8_t * payload = NULL, size_t length = 0, bool mask = false, bool fin = true, bool headerToPayload = false);
+    virtual void messageReceived(WSclient_t * client, WSopcode_t opcode, uint8_t * payload, size_t length, bool fin) = 0;
 
-        void headerDone(WSclient_t * client);
+    uint8_t createHeader(uint8_t * buf, WSopcode_t opcode, size_t length, bool mask, uint8_t maskKey[4], bool fin);
+    bool sendFrameHeader(WSclient_t * client, WSopcode_t opcode, size_t length = 0, bool fin = true);
+    bool sendFrame(WSclient_t * client, WSopcode_t opcode, uint8_t * payload = NULL, size_t length = 0, bool fin = true, bool headerToPayload = false);
 
-        void handleWebsocket(WSclient_t * client);
+    void headerDone(WSclient_t * client);
 
-        bool handleWebsocketWaitFor(WSclient_t * client, size_t size);
-        void handleWebsocketCb(WSclient_t * client);
-        void handleWebsocketPayloadCb(WSclient_t * client, bool ok, uint8_t * payload);
+    void handleWebsocket(WSclient_t * client);
 
-        String acceptKey(String & clientKey);
-        String base64_encode(uint8_t * data, size_t length);
+    bool handleWebsocketWaitFor(WSclient_t * client, size_t size);
+    void handleWebsocketCb(WSclient_t * client);
+    void handleWebsocketPayloadCb(WSclient_t * client, bool ok, uint8_t * payload);
 
-        bool readCb(WSclient_t * client, uint8_t *out, size_t n, WSreadWaitCb cb);
-        virtual size_t write(WSclient_t * client, uint8_t *out, size_t n);
-        size_t write(WSclient_t * client, const char *out);
+    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);
+    virtual size_t write(WSclient_t * client, uint8_t * out, size_t n);
+    size_t write(WSclient_t * client, const char * out);
 
+    void enableHeartbeat(WSclient_t * client, uint32_t pingInterval, uint32_t pongTimeout, uint8_t disconnectTimeoutCount);
+    void handleHBTimeout(WSclient_t * client);
 };
 
 #ifndef UNUSED

src/WebSocketsClient.cpp

@@ -26,9 +26,11 @@
 #include "WebSocketsClient.h"
 
 WebSocketsClient::WebSocketsClient() {
-    _cbEvent = NULL;
-    _client.num = 0;
+    _cbEvent             = NULL;
+    _client.num          = 0;
+    _client.cIsClient    = true;
     _client.extraHeaders = WEBSOCKETS_STRING("Origin: file://");
+    _reconnectInterval   = 500;
 }
 
 WebSocketsClient::~WebSocketsClient() {
@@ -38,32 +40,37 @@ WebSocketsClient::~WebSocketsClient() {
 /**
  * calles to init the Websockets server
  */
-void WebSocketsClient::begin(const char *host, uint16_t port, const char * url, const char * protocol) {
+void WebSocketsClient::begin(const char * host, uint16_t port, const char * url, const char * protocol) {
     _host = host;
     _port = port;
-#if (WEBSOCKETS_NETWORK_TYPE == NETWORK_ESP8266) || (WEBSOCKETS_NETWORK_TYPE == NETWORK_ESP32)
+#if defined(HAS_SSL)
     _fingerprint = "";
+    _CA_cert     = NULL;
 #endif
 
-    _client.num = 0;
+    _client.num    = 0;
     _client.status = WSC_NOT_CONNECTED;
-    _client.tcp = NULL;
-#if (WEBSOCKETS_NETWORK_TYPE == NETWORK_ESP8266) || (WEBSOCKETS_NETWORK_TYPE == NETWORK_ESP32)
+    _client.tcp    = NULL;
+#if defined(HAS_SSL)
     _client.isSSL = false;
-    _client.ssl = NULL;
+    _client.ssl   = NULL;
 #endif
-    _client.cUrl = url;
-    _client.cCode = 0;
-    _client.cIsUpgrade = false;
-    _client.cIsWebsocket = true;
-    _client.cKey = "";
-    _client.cAccept = "";
-    _client.cProtocol = protocol;
-    _client.cExtensions = "";
-    _client.cVersion = 0;
+    _client.cUrl                = url;
+    _client.cCode               = 0;
+    _client.cIsUpgrade          = false;
+    _client.cIsWebsocket        = true;
+    _client.cKey                = "";
+    _client.cAccept             = "";
+    _client.cProtocol           = protocol;
+    _client.cExtensions         = "";
+    _client.cVersion            = 0;
     _client.base64Authorization = "";
-    _client.plainAuthorization = "";
-    _client.isSocketIO = false;
+    _client.plainAuthorization  = "";
+    _client.isSocketIO          = false;
+
+    _client.lastPing         = 0;
+    _client.pongReceived     = false;
+    _client.pongTimeoutCount = 0;
 
 #ifdef ESP8266
     randomSeed(RANDOM_REG32);
@@ -71,12 +78,11 @@ 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)
+#if(WEBSOCKETS_NETWORK_TYPE == NETWORK_ESP8266_ASYNC)
     asyncConnect();
 #endif
 
     _lastConnectionFail = 0;
-    _reconnectInterval = 500;
 }
 
 void WebSocketsClient::begin(String host, uint16_t port, String url, String protocol) {
@@ -87,19 +93,27 @@ void WebSocketsClient::begin(IPAddress host, uint16_t port, const char * url, co
     return begin(host.toString().c_str(), port, url, protocol);
 }
 
-#if (WEBSOCKETS_NETWORK_TYPE == NETWORK_ESP8266) || (WEBSOCKETS_NETWORK_TYPE == NETWORK_ESP32)
-void WebSocketsClient::beginSSL(const char *host, uint16_t port, const char * url, const char * fingerprint, const char * protocol) {
+#if defined(HAS_SSL)
+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;
+    _fingerprint  = fingerprint;
+    _CA_cert      = NULL;
 }
 
 void WebSocketsClient::beginSSL(String host, uint16_t port, String url, String fingerprint, String protocol) {
     beginSSL(host.c_str(), port, url.c_str(), fingerprint.c_str(), protocol.c_str());
 }
+
+void WebSocketsClient::beginSslWithCA(const char * host, uint16_t port, const char * url, const char * CA_cert, const char * protocol) {
+    begin(host, port, url, protocol);
+    _client.isSSL = true;
+    _fingerprint  = "";
+    _CA_cert      = CA_cert;
+}
 #endif
 
-void WebSocketsClient::beginSocketIO(const char *host, uint16_t port, const char * url, const char * protocol) {
+void WebSocketsClient::beginSocketIO(const char * host, uint16_t port, const char * url, const char * protocol) {
     begin(host, port, url, protocol);
     _client.isSocketIO = true;
 }
@@ -108,31 +122,40 @@ void WebSocketsClient::beginSocketIO(String host, uint16_t port, String url, Str
     beginSocketIO(host.c_str(), port, url.c_str(), protocol.c_str());
 }
 
-#if (WEBSOCKETS_NETWORK_TYPE == NETWORK_ESP8266) || (WEBSOCKETS_NETWORK_TYPE == NETWORK_ESP32)
-void WebSocketsClient::beginSocketIOSSL(const char *host, uint16_t port, const char * url, const char * protocol) {
+#if defined(HAS_SSL)
+void WebSocketsClient::beginSocketIOSSL(const char * host, uint16_t port, const char * url, const char * protocol) {
     begin(host, port, url, protocol);
     _client.isSocketIO = true;
-    _client.isSSL = true;
-    _fingerprint = "";
+    _client.isSSL      = true;
+    _fingerprint       = "";
 }
 
 void WebSocketsClient::beginSocketIOSSL(String host, uint16_t port, String url, String protocol) {
     beginSocketIOSSL(host.c_str(), port, url.c_str(), protocol.c_str());
 }
+
+void WebSocketsClient::beginSocketIOSSLWithCA(const char * host, uint16_t port, const char * url, const char * CA_cert, const char * protocol) {
+    begin(host, port, url, protocol);
+    _client.isSocketIO = true;
+    _client.isSSL      = true;
+    _fingerprint       = "";
+    _CA_cert           = CA_cert;
+}
 #endif
 
-#if (WEBSOCKETS_NETWORK_TYPE != NETWORK_ESP8266_ASYNC)
+#if(WEBSOCKETS_NETWORK_TYPE != NETWORK_ESP8266_ASYNC)
 /**
  * called in arduino loop
  */
 void WebSocketsClient::loop(void) {
+    WEBSOCKETS_YIELD();
     if(!clientIsConnected(&_client)) {
         // do not flood the server
         if((millis() - _lastConnectionFail) < _reconnectInterval) {
             return;
         }
 
-#if (WEBSOCKETS_NETWORK_TYPE == NETWORK_ESP8266) || (WEBSOCKETS_NETWORK_TYPE == NETWORK_ESP32)
+#if defined(HAS_SSL)
         if(_client.isSSL) {
             DEBUG_WEBSOCKETS("[WS-Client] connect wss...\n");
             if(_client.ssl) {
@@ -140,15 +163,25 @@ void WebSocketsClient::loop(void) {
                 _client.ssl = NULL;
                 _client.tcp = NULL;
             }
-            _client.ssl = new WiFiClientSecure();
+            _client.ssl = new WEBSOCKETS_NETWORK_SSL_CLASS();
             _client.tcp = _client.ssl;
+            if(_CA_cert) {
+                DEBUG_WEBSOCKETS("[WS-Client] setting CA certificate");
+#if defined(ESP32)
+                _client.ssl->setCACert(_CA_cert);
+#elif defined(ESP8266)
+                _client.ssl->setCACert((const uint8_t *)_CA_cert, strlen(_CA_cert) + 1);
+#else
+#error setCACert not implemented
+#endif
+            }
         } else {
             DEBUG_WEBSOCKETS("[WS-Client] connect ws...\n");
             if(_client.tcp) {
                 delete _client.tcp;
                 _client.tcp = NULL;
             }
-            _client.tcp = new WiFiClient();
+            _client.tcp = new WEBSOCKETS_NETWORK_CLASS();
         }
 #else
         _client.tcp = new WEBSOCKETS_NETWORK_CLASS();
@@ -158,17 +191,25 @@ void WebSocketsClient::loop(void) {
             DEBUG_WEBSOCKETS("[WS-Client] creating Network class failed!");
             return;
         }
-
+        WEBSOCKETS_YIELD();
+#if defined(ESP32)
+        if(_client.tcp->connect(_host.c_str(), _port, WEBSOCKETS_TCP_TIMEOUT)) {
+#else
         if(_client.tcp->connect(_host.c_str(), _port)) {
+#endif
             connectedCb();
             _lastConnectionFail = 0;
         } else {
             connectFailedCb();
             _lastConnectionFail = millis();
-
         }
     } else {
         handleClientData();
+        WEBSOCKETS_YIELD();
+        if(_client.status == WSC_CONNECTED) {
+            handleHBPing();
+            handleHBTimeout(&_client);
+        }
     }
 }
 #endif
@@ -191,28 +232,34 @@ void WebSocketsClient::onEvent(WebSocketClientEvent cbEvent) {
  */
 bool WebSocketsClient::sendTXT(uint8_t * payload, size_t length, bool headerToPayload) {
     if(length == 0) {
-        length = strlen((const char *) payload);
+        length = strlen((const char *)payload);
     }
     if(clientIsConnected(&_client)) {
-        return sendFrame(&_client, WSop_text, payload, length, true, true, headerToPayload);
+        return sendFrame(&_client, WSop_text, payload, length, true, headerToPayload);
     }
     return false;
 }
 
 bool WebSocketsClient::sendTXT(const uint8_t * payload, size_t length) {
-    return sendTXT((uint8_t *) payload, length);
+    return sendTXT((uint8_t *)payload, length);
 }
 
 bool WebSocketsClient::sendTXT(char * payload, size_t length, bool headerToPayload) {
-    return sendTXT((uint8_t *) payload, length, headerToPayload);
+    return sendTXT((uint8_t *)payload, length, headerToPayload);
 }
 
 bool WebSocketsClient::sendTXT(const char * payload, size_t length) {
-    return sendTXT((uint8_t *) payload, length);
+    return sendTXT((uint8_t *)payload, length);
 }
 
 bool WebSocketsClient::sendTXT(String & payload) {
-    return sendTXT((uint8_t *) payload.c_str(), payload.length());
+    return sendTXT((uint8_t *)payload.c_str(), payload.length());
+}
+
+bool WebSocketsClient::sendTXT(char payload) {
+    uint8_t buf[WEBSOCKETS_MAX_HEADER_SIZE + 2] = { 0x00 };
+    buf[WEBSOCKETS_MAX_HEADER_SIZE]             = payload;
+    return sendTXT(buf, 1, true);
 }
 
 /**
@@ -225,13 +272,13 @@ bool WebSocketsClient::sendTXT(String & payload) {
  */
 bool WebSocketsClient::sendBIN(uint8_t * payload, size_t length, bool headerToPayload) {
     if(clientIsConnected(&_client)) {
-        return sendFrame(&_client, WSop_binary, payload, length, true, true, headerToPayload);
+        return sendFrame(&_client, WSop_binary, payload, length, true, headerToPayload);
     }
     return false;
 }
 
 bool WebSocketsClient::sendBIN(const uint8_t * payload, size_t length) {
-    return sendBIN((uint8_t *) payload, length);
+    return sendBIN((uint8_t *)payload, length);
 }
 
 /**
@@ -242,13 +289,16 @@ bool WebSocketsClient::sendBIN(const uint8_t * payload, size_t length) {
  */
 bool WebSocketsClient::sendPing(uint8_t * payload, size_t length) {
     if(clientIsConnected(&_client)) {
-        return sendFrame(&_client, WSop_ping, payload, length, true);
+        bool sent = sendFrame(&_client, WSop_ping, payload, length);
+        if(sent)
+            _client.lastPing = millis();
+        return sent;
     }
     return false;
 }
 
 bool WebSocketsClient::sendPing(String & payload) {
-    return sendPing((uint8_t *) payload.c_str(), payload.length());
+    return sendPing((uint8_t *)payload.c_str(), payload.length());
 }
 
 /**
@@ -271,7 +321,7 @@ void WebSocketsClient::setAuthorization(const char * user, const char * password
         String auth = user;
         auth += ":";
         auth += password;
-        _client.base64Authorization = base64_encode((uint8_t *) auth.c_str(), auth.length());
+        _client.base64Authorization = base64_encode((uint8_t *)auth.c_str(), auth.length());
     }
 }
 
@@ -304,6 +354,10 @@ void WebSocketsClient::setReconnectInterval(unsigned long time) {
     _reconnectInterval = time;
 }
 
+bool WebSocketsClient::isConnected(void) {
+    return (_client.status == WSC_CONNECTED);
+}
+
 //#################################################################################
 //#################################################################################
 //#################################################################################
@@ -330,15 +384,18 @@ void WebSocketsClient::messageReceived(WSclient_t * client, WSopcode_t opcode, u
         case WSop_continuation:
             type = fin ? WStype_FRAGMENT_FIN : WStype_FRAGMENT;
             break;
-        case WSop_close:
         case WSop_ping:
+            type = WStype_PING;
+            break;
         case WSop_pong:
+            type = WStype_PONG;
+            break;
+        case WSop_close:
         default:
             break;
     }
 
     runCbEvent(type, payload, length);
-
 }
 
 /**
@@ -346,10 +403,9 @@ void WebSocketsClient::messageReceived(WSclient_t * client, WSopcode_t opcode, u
  * @param client WSclient_t *  ptr to the client struct
  */
 void WebSocketsClient::clientDisconnect(WSclient_t * client) {
-
     bool event = false;
 
-#if (WEBSOCKETS_NETWORK_TYPE == NETWORK_ESP8266) || (WEBSOCKETS_NETWORK_TYPE == NETWORK_ESP32)
+#if(WEBSOCKETS_NETWORK_TYPE == NETWORK_ESP8266) || (WEBSOCKETS_NETWORK_TYPE == NETWORK_ESP32)
     if(client->isSSL && client->ssl) {
         if(client->ssl->connected()) {
             client->ssl->flush();
@@ -364,13 +420,13 @@ void WebSocketsClient::clientDisconnect(WSclient_t * client) {
 
     if(client->tcp) {
         if(client->tcp->connected()) {
-#if (WEBSOCKETS_NETWORK_TYPE != NETWORK_ESP8266_ASYNC)
+#if(WEBSOCKETS_NETWORK_TYPE != NETWORK_ESP8266_ASYNC)
             client->tcp->flush();
 #endif
             client->tcp->stop();
         }
         event = true;
-#if (WEBSOCKETS_NETWORK_TYPE == NETWORK_ESP8266_ASYNC)
+#if(WEBSOCKETS_NETWORK_TYPE == NETWORK_ESP8266_ASYNC)
         client->status = WSC_NOT_CONNECTED;
 #else
         delete client->tcp;
@@ -378,13 +434,13 @@ void WebSocketsClient::clientDisconnect(WSclient_t * client) {
         client->tcp = NULL;
     }
 
-    client->cCode = 0;
-    client->cKey = "";
-    client->cAccept = "";
-    client->cVersion = 0;
-    client->cIsUpgrade = false;
+    client->cCode        = 0;
+    client->cKey         = "";
+    client->cAccept      = "";
+    client->cVersion     = 0;
+    client->cIsUpgrade   = false;
     client->cIsWebsocket = false;
-    client->cSessionId = "";
+    client->cSessionId   = "";
 
     client->status = WSC_NOT_CONNECTED;
 
@@ -400,7 +456,6 @@ void WebSocketsClient::clientDisconnect(WSclient_t * client) {
  * @return true = conneted
  */
 bool WebSocketsClient::clientIsConnected(WSclient_t * client) {
-
     if(!client->tcp) {
         return false;
     }
@@ -425,7 +480,7 @@ bool WebSocketsClient::clientIsConnected(WSclient_t * client) {
 
     return false;
 }
-#if (WEBSOCKETS_NETWORK_TYPE != NETWORK_ESP8266_ASYNC)
+#if(WEBSOCKETS_NETWORK_TYPE != NETWORK_ESP8266_ASYNC)
 /**
  * Handel incomming data from Client
  */
@@ -436,8 +491,7 @@ void WebSocketsClient::handleClientData(void) {
             case WSC_HEADER: {
                 String headerLine = _client.tcp->readStringUntil('\n');
                 handleHeader(&_client, &headerLine);
-            }
-                break;
+            } break;
             case WSC_CONNECTED:
                 WebSockets::handleWebsocket(&_client);
                 break;
@@ -446,9 +500,7 @@ void WebSocketsClient::handleClientData(void) {
                 break;
         }
     }
-#if (WEBSOCKETS_NETWORK_TYPE == NETWORK_ESP8266) || (WEBSOCKETS_NETWORK_TYPE == NETWORK_ESP32)
-    delay(0);
-#endif
+    WEBSOCKETS_YIELD();
 }
 #endif
 
@@ -457,7 +509,6 @@ void WebSocketsClient::handleClientData(void) {
  * @param client WSclient_t *  ptr to the client struct
  */
 void WebSocketsClient::sendHeader(WSclient_t * client) {
-
     static const char * NEW_LINE = "\r\n";
 
     DEBUG_WEBSOCKETS("[WS-Client][sendHeader] sending header...\n");
@@ -476,7 +527,7 @@ void WebSocketsClient::sendHeader(WSclient_t * client) {
 
     String handshake;
     bool ws_header = true;
-    String url = client->cUrl;
+    String url     = client->cUrl;
 
     if(client->isSocketIO) {
         if(client->cSessionId.length() == 0) {
@@ -489,15 +540,17 @@ void WebSocketsClient::sendHeader(WSclient_t * client) {
     }
 
     handshake = WEBSOCKETS_STRING("GET ");
-    handshake += url + WEBSOCKETS_STRING(" HTTP/1.1\r\n"
-            "Host: ");
+    handshake += url + WEBSOCKETS_STRING(
+                           " HTTP/1.1\r\n"
+                           "Host: ");
     handshake += _host + ":" + _port + NEW_LINE;
 
     if(ws_header) {
-        handshake += WEBSOCKETS_STRING("Connection: Upgrade\r\n"
-                "Upgrade: websocket\r\n"
-                "Sec-WebSocket-Version: 13\r\n"
-                "Sec-WebSocket-Key: ");
+        handshake += WEBSOCKETS_STRING(
+            "Connection: Upgrade\r\n"
+            "Upgrade: websocket\r\n"
+            "Sec-WebSocket-Version: 13\r\n"
+            "Sec-WebSocket-Key: ");
         handshake += client->cKey + NEW_LINE;
 
         if(client->cProtocol.length() > 0) {
@@ -532,15 +585,14 @@ void WebSocketsClient::sendHeader(WSclient_t * client) {
 
     handshake += NEW_LINE;
 
-    DEBUG_WEBSOCKETS("[WS-Client][sendHeader] handshake %s", (uint8_t* )handshake.c_str());
-    write(client, (uint8_t*) handshake.c_str(), handshake.length());
+    DEBUG_WEBSOCKETS("[WS-Client][sendHeader] handshake %s", (uint8_t *)handshake.c_str());
+    write(client, (uint8_t *)handshake.c_str(), handshake.length());
 
-#if (WEBSOCKETS_NETWORK_TYPE == NETWORK_ESP8266_ASYNC)
+#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 (%luus).\n", (micros() - start));
-
 }
 
 /**
@@ -548,8 +600,7 @@ void WebSocketsClient::sendHeader(WSclient_t * client) {
  * @param client WSclient_t *  ptr to the client struct
  */
 void WebSocketsClient::handleHeader(WSclient_t * client, String * headerLine) {
-
-    headerLine->trim(); // remove \r
+    headerLine->trim();    // remove \r
 
     if(headerLine->length() > 0) {
         DEBUG_WEBSOCKETS("[WS-Client][handleHeader] RX: %s\n", headerLine->c_str());
@@ -557,8 +608,8 @@ void WebSocketsClient::handleHeader(WSclient_t * client, String * headerLine) {
         if(headerLine->startsWith(WEBSOCKETS_STRING("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(':'));
+        } else if(headerLine->indexOf(':') >= 0) {
+            String headerName  = headerLine->substring(0, headerLine->indexOf(':'));
             String headerValue = headerLine->substring(headerLine->indexOf(':') + 1);
 
             // remove space in the beginning  (RFC2616)
@@ -576,7 +627,7 @@ void WebSocketsClient::handleHeader(WSclient_t * client, String * headerLine) {
                 }
             } else if(headerName.equalsIgnoreCase(WEBSOCKETS_STRING("Sec-WebSocket-Accept"))) {
                 client->cAccept = headerValue;
-                client->cAccept.trim(); // see rfc6455
+                client->cAccept.trim();    // see rfc6455
             } else if(headerName.equalsIgnoreCase(WEBSOCKETS_STRING("Sec-WebSocket-Protocol"))) {
                 client->cProtocol = headerValue;
             } else if(headerName.equalsIgnoreCase(WEBSOCKETS_STRING("Sec-WebSocket-Extensions"))) {
@@ -595,10 +646,9 @@ void WebSocketsClient::handleHeader(WSclient_t * client, String * headerLine) {
         }
 
         (*headerLine) = "";
-#if (WEBSOCKETS_NETWORK_TYPE == NETWORK_ESP8266_ASYNC)
+#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");
@@ -620,16 +670,16 @@ void WebSocketsClient::handleHeader(WSclient_t * client, String * headerLine) {
 
         if(ok) {
             switch(client->cCode) {
-                case 101:  ///< Switching Protocols
+                case 101:    ///< Switching Protocols
 
                     break;
                 case 200:
                     if(client->isSocketIO) {
                         break;
                     }
-                case 403: ///< Forbidden
+                case 403:    ///< Forbidden
                     // todo handle login
-                default:   ///< Server dont unterstand requrst
+                default:    ///< Server dont unterstand requrst
                     ok = false;
                     DEBUG_WEBSOCKETS("[WS-Client][handleHeader] serverCode is not 101 (%d)\n", client->cCode);
                     clientDisconnect(client);
@@ -639,7 +689,6 @@ void WebSocketsClient::handleHeader(WSclient_t * client, String * headerLine) {
         }
 
         if(ok) {
-
             if(client->cAccept.length() == 0) {
                 ok = false;
             } else {
@@ -653,14 +702,21 @@ void WebSocketsClient::handleHeader(WSclient_t * client, String * headerLine) {
         }
 
         if(ok) {
-
             DEBUG_WEBSOCKETS("[WS-Client][handleHeader] Websocket connection init done.\n");
             headerDone(client);
 
-            runCbEvent(WStype_CONNECTED, (uint8_t *) client->cUrl.c_str(), client->cUrl.length());
-
+            runCbEvent(WStype_CONNECTED, (uint8_t *)client->cUrl.c_str(), client->cUrl.length());
+#if(WEBSOCKETS_NETWORK_TYPE != NETWORK_ESP8266_ASYNC)
         } else if(clientIsConnected(client) && client->isSocketIO && client->cSessionId.length() > 0) {
+            if(_client.tcp->available()) {
+                // read not needed data
+                DEBUG_WEBSOCKETS("[WS-Client][handleHeader] still data in buffer (%d), clean up.\n", _client.tcp->available());
+                while(_client.tcp->available() > 0) {
+                    _client.tcp->read();
+                }
+            }
             sendHeader(client);
+#endif
         } else {
             DEBUG_WEBSOCKETS("[WS-Client][handleHeader] no Websocket connection close.\n");
             _lastConnectionFail = millis();
@@ -673,54 +729,58 @@ void WebSocketsClient::handleHeader(WSclient_t * client, String * headerLine) {
 }
 
 void WebSocketsClient::connectedCb() {
-
     DEBUG_WEBSOCKETS("[WS-Client] connected to %s:%u.\n", _host.c_str(), _port);
 
-#if (WEBSOCKETS_NETWORK_TYPE == NETWORK_ESP8266_ASYNC)
+#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;
+        DEBUG_WEBSOCKETS("[WS-Server][%d] Disconnect client\n", client->num);
+        client->status = WSC_NOT_CONNECTED;
+        client->tcp    = NULL;
 
-                        // reconnect
-                        c->asyncConnect();
+        // reconnect
+        c->asyncConnect();
 
-                        return true;
-                    }, this, std::placeholders::_1, &_client));
+        return true;
+    },
+        this, std::placeholders::_1, &_client));
 #endif
 
     _client.status = WSC_HEADER;
 
-#if (WEBSOCKETS_NETWORK_TYPE != NETWORK_ESP8266_ASYNC)
+#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)
+#if(WEBSOCKETS_NETWORK_TYPE == NETWORK_ESP8266) || (WEBSOCKETS_NETWORK_TYPE == NETWORK_ESP32)
     _client.tcp->setNoDelay(true);
+#endif
 
+#if defined(HAS_SSL)
     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;
         }
+    } else if(_client.isSSL && !_CA_cert) {
+#if defined(wificlientbearssl_h) && !defined(USING_AXTLS) && !defined(wificlientsecure_h)
+        _client.ssl->setInsecure();
+#endif
     }
 #endif
 
     // send Header to Server
     sendHeader(&_client);
-
 }
 
 void WebSocketsClient::connectFailedCb() {
-    DEBUG_WEBSOCKETS("[WS-Client] connection to %s:%u Faild\n", _host.c_str(), _port);
+    DEBUG_WEBSOCKETS("[WS-Client] connection to %s:%u Failed\n", _host.c_str(), _port);
 }
 
-#if (WEBSOCKETS_NETWORK_TYPE == NETWORK_ESP8266_ASYNC)
+#if(WEBSOCKETS_NETWORK_TYPE == NETWORK_ESP8266_ASYNC)
 
 void WebSocketsClient::asyncConnect() {
-
     DEBUG_WEBSOCKETS("[WS-Client] asyncConnect...\n");
 
     AsyncClient * tcpclient = new AsyncClient();
@@ -730,33 +790,67 @@ void WebSocketsClient::asyncConnect() {
         return;
     }
 
-    tcpclient->onDisconnect([](void *obj, AsyncClient* c) {
-                c->free();
-                delete c;
-            });
+    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->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();
+    tcpclient->onError(std::bind([](WebSocketsClient * ws, AsyncClient * tcp) {
+        ws->connectFailedCb();
 
-                        // reconnect
-                        ws->asyncConnect();
-                    }, this, std::placeholders::_2));
+        // reconnect
+        ws->asyncConnect();
+    },
+        this, std::placeholders::_2));
 
     if(!tcpclient->connect(_host.c_str(), _port)) {
         connectFailedCb();
         delete tcpclient;
     }
-
 }
 
 #endif
+
+/**
+ * send heartbeat ping to server in set intervals
+ */
+void WebSocketsClient::handleHBPing() {
+    if(_client.pingInterval == 0)
+        return;
+    uint32_t pi = millis() - _client.lastPing;
+    if(pi > _client.pingInterval) {
+        DEBUG_WEBSOCKETS("[WS-Client] sending HB ping\n");
+        if(sendPing()) {
+            _client.lastPing     = millis();
+            _client.pongReceived = false;
+        }
+    }
+}
+
+/**
+ * enable ping/pong heartbeat process
+ * @param pingInterval uint32_t how often ping will be sent
+ * @param pongTimeout uint32_t millis after which pong should timout if not received
+ * @param disconnectTimeoutCount uint8_t how many timeouts before disconnect, 0=> do not disconnect
+ */
+void WebSocketsClient::enableHeartbeat(uint32_t pingInterval, uint32_t pongTimeout, uint8_t disconnectTimeoutCount) {
+    WebSockets::enableHeartbeat(&_client, pingInterval, pongTimeout, disconnectTimeoutCount);
+}
+
+/**
+ * disable ping/pong heartbeat process
+ */
+void WebSocketsClient::disableHeartbeat() {
+    _client.pingInterval = 0;
+}

src/WebSocketsClient.h

@@ -27,110 +27,119 @@
 
 #include "WebSockets.h"
 
-class WebSocketsClient: private WebSockets {
-    public:
+class WebSocketsClient : protected WebSockets {
+  public:
 #ifdef __AVR__
-        typedef void (*WebSocketClientEvent)(WStype_t type, uint8_t * payload, size_t length);
+    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;
+    typedef std::function<void(WStype_t type, uint8_t * payload, size_t length)> WebSocketClientEvent;
 #endif
 
+    WebSocketsClient(void);
+    virtual ~WebSocketsClient(void);
 
-        WebSocketsClient(void);
-        virtual ~WebSocketsClient(void);
+    void begin(const char * host, uint16_t port, const char * url = "/", const char * protocol = "arduino");
+    void begin(String host, uint16_t port, String url = "/", String protocol = "arduino");
+    void begin(IPAddress host, uint16_t port, const char * url = "/", const char * protocol = "arduino");
 
-        void begin(const char *host, uint16_t port, const char * url = "/", const char * protocol = "arduino");
-        void begin(String host, uint16_t port, String url = "/", String protocol = "arduino");
-        void begin(IPAddress host, uint16_t port, const char * url = "/", const char * protocol = "arduino");
-
-#if (WEBSOCKETS_NETWORK_TYPE == NETWORK_ESP8266) || (WEBSOCKETS_NETWORK_TYPE == NETWORK_ESP32)
-        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");
+#if defined(HAS_SSL)
+    void beginSSL(const char * host, uint16_t port, const char * url = "/", const char * = "", const char * protocol = "arduino");
+    void beginSSL(String host, uint16_t port, String url = "/", String fingerprint = "", String protocol = "arduino");
+    void beginSslWithCA(const char * host, uint16_t port, const char * url = "/", const char * CA_cert = NULL, const char * 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");
+    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) || (WEBSOCKETS_NETWORK_TYPE == NETWORK_ESP32)
-        void beginSocketIOSSL(const char *host, uint16_t port, const char * url = "/socket.io/?EIO=3", const char * protocol = "arduino");
-        void beginSocketIOSSL(String host, uint16_t port, String url = "/socket.io/?EIO=3", String protocol = "arduino");
+#if defined(HAS_SSL)
+    void beginSocketIOSSL(const char * host, uint16_t port, const char * url = "/socket.io/?EIO=3", const char * protocol = "arduino");
+    void beginSocketIOSSL(String host, uint16_t port, String url = "/socket.io/?EIO=3", String protocol = "arduino");
+    void beginSocketIOSSLWithCA(const char * host, uint16_t port, const char * url = "/socket.io/?EIO=3", const char * CA_cert = NULL, const char * protocol = "arduino");
 #endif
 
-#if (WEBSOCKETS_NETWORK_TYPE != NETWORK_ESP8266_ASYNC)
-        void loop(void);
+#if(WEBSOCKETS_NETWORK_TYPE != NETWORK_ESP8266_ASYNC)
+    void loop(void);
 #else
-        // Async interface not need a loop call
-        void loop(void) __attribute__ ((deprecated)) {}
+    // Async interface not need a loop call
+    void loop(void) __attribute__((deprecated)) {}
 #endif
 
-        void onEvent(WebSocketClientEvent cbEvent);
+    void onEvent(WebSocketClientEvent cbEvent);
 
-        bool sendTXT(uint8_t * payload, size_t length = 0, bool headerToPayload = false);
-        bool sendTXT(const uint8_t * payload, size_t length = 0);
-        bool sendTXT(char * payload, size_t length = 0, bool headerToPayload = false);
-        bool sendTXT(const char * payload, size_t length = 0);
-        bool sendTXT(String & payload);
+    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);
+    bool sendTXT(char payload);
 
-        bool sendBIN(uint8_t * payload, size_t length, bool headerToPayload = false);
-        bool 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);
+    bool sendPing(uint8_t * payload = NULL, size_t length = 0);
+    bool sendPing(String & payload);
 
-        void disconnect(void);
+    void disconnect(void);
 
-        void setAuthorization(const char * user, const char * password);
-        void setAuthorization(const char * auth);
-	
-        void setExtraHeaders(const char * extraHeaders = NULL);
+    void setAuthorization(const char * user, const char * password);
+    void setAuthorization(const char * auth);
 
-        void setReconnectInterval(unsigned long time);
+    void setExtraHeaders(const char * extraHeaders = NULL);
 
-    protected:
-        String _host;
-        uint16_t _port;
+    void setReconnectInterval(unsigned long time);
 
-#if (WEBSOCKETS_NETWORK_TYPE == NETWORK_ESP8266) || (WEBSOCKETS_NETWORK_TYPE == NETWORK_ESP32)
-        String _fingerprint;
+    void enableHeartbeat(uint32_t pingInterval, uint32_t pongTimeout, uint8_t disconnectTimeoutCount);
+    void disableHeartbeat();
+
+  protected:
+    String _host;
+    uint16_t _port;
+
+    bool isConnected(void);
+
+#if defined(HAS_SSL)
+    String _fingerprint;
+    const char * _CA_cert;
 #endif
-        WSclient_t _client;
+    WSclient_t _client;
 
-        WebSocketClientEvent _cbEvent;
+    WebSocketClientEvent _cbEvent;
 
-        unsigned long _lastConnectionFail;
-        unsigned long _reconnectInterval;
+    unsigned long _lastConnectionFail;
+    unsigned long _reconnectInterval;
 
-        void messageReceived(WSclient_t * client, WSopcode_t opcode, uint8_t * payload, size_t length, bool fin);
+    void messageReceived(WSclient_t * client, WSopcode_t opcode, uint8_t * payload, size_t length, bool fin);
 
-        void clientDisconnect(WSclient_t * client);
-        bool clientIsConnected(WSclient_t * client);
+    void clientDisconnect(WSclient_t * client);
+    bool clientIsConnected(WSclient_t * client);
 
-#if (WEBSOCKETS_NETWORK_TYPE != NETWORK_ESP8266_ASYNC)
-        void handleClientData(void);
+#if(WEBSOCKETS_NETWORK_TYPE != NETWORK_ESP8266_ASYNC)
+    void handleClientData(void);
 #endif
 
-        void sendHeader(WSclient_t * client);
-        void handleHeader(WSclient_t * client, String * headerLine);
+    void sendHeader(WSclient_t * client);
+    void handleHeader(WSclient_t * client, String * headerLine);
 
-        void connectedCb();
-        void connectFailedCb();
+    void connectedCb();
+    void connectFailedCb();
 
-#if (WEBSOCKETS_NETWORK_TYPE == NETWORK_ESP8266_ASYNC)
-        void asyncConnect();
+    void handleHBPing();    // send ping in specified intervals
+
+#if(WEBSOCKETS_NETWORK_TYPE == NETWORK_ESP8266_ASYNC)
+    void asyncConnect();
 #endif
 
-        /**
+    /**
          * called for sending a Event to the app
          * @param type WStype_t
          * @param payload uint8_t *
          * @param length size_t
          */
-        virtual void runCbEvent(WStype_t type, uint8_t * payload, size_t length) {
-            if(_cbEvent) {
-                _cbEvent(type, payload, length);
-            }
+    virtual void runCbEvent(WStype_t type, uint8_t * payload, size_t length) {
+        if(_cbEvent) {
+            _cbEvent(type, payload, length);
         }
-
+    }
 };
 
 #endif /* WEBSOCKETSCLIENT_H_ */

src/WebSocketsServer.cpp

@@ -26,34 +26,37 @@
 #include "WebSocketsServer.h"
 
 WebSocketsServer::WebSocketsServer(uint16_t port, String origin, String protocol) {
-    _port = port;
-    _origin = origin;
-    _protocol = protocol;
-    _runnning = false;
+    _port                   = port;
+    _origin                 = origin;
+    _protocol               = protocol;
+    _runnning               = false;
+    _pingInterval           = 0;
+    _pongTimeout            = 0;
+    _disconnectTimeoutCount = 0;
 
     _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);
+#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;
+    _mandatoryHttpHeaders     = NULL;
     _mandatoryHttpHeaderCount = 0;
 
     memset(&_clients[0], 0x00, (sizeof(WSclient_t) * WEBSOCKETS_SERVER_CLIENT_MAX));
 }
 
-
 WebSocketsServer::~WebSocketsServer() {
     // disconnect all clients
-	close();
+    close();
 
-    if (_mandatoryHttpHeaders)
+    if(_mandatoryHttpHeaders)
         delete[] _mandatoryHttpHeaders;
 
     _mandatoryHttpHeaderCount = 0;
@@ -69,34 +72,38 @@ void WebSocketsServer::begin(void) {
     for(uint8_t i = 0; i < WEBSOCKETS_SERVER_CLIENT_MAX; i++) {
         client = &_clients[i];
 
-        client->num = i;
+        client->num    = i;
         client->status = WSC_NOT_CONNECTED;
-        client->tcp = NULL;
-#if (WEBSOCKETS_NETWORK_TYPE == NETWORK_ESP8266) || (WEBSOCKETS_NETWORK_TYPE == NETWORK_ESP32)
+        client->tcp    = NULL;
+#if(WEBSOCKETS_NETWORK_TYPE == NETWORK_ESP8266) || (WEBSOCKETS_NETWORK_TYPE == NETWORK_ESP32)
         client->isSSL = false;
-        client->ssl = NULL;
+        client->ssl   = NULL;
 #endif
-        client->cUrl = "";
-        client->cCode = 0;
-        client->cKey = "";
-        client->cProtocol = "";
-        client->cVersion = 0;
-        client->cIsUpgrade = false;
+        client->cUrl         = "";
+        client->cCode        = 0;
+        client->cKey         = "";
+        client->cProtocol    = "";
+        client->cVersion     = 0;
+        client->cIsUpgrade   = false;
         client->cIsWebsocket = false;
 
         client->base64Authorization = "";
 
         client->cWsRXsize = 0;
 
-#if (WEBSOCKETS_NETWORK_TYPE == NETWORK_ESP8266_ASYNC)
+#if(WEBSOCKETS_NETWORK_TYPE == NETWORK_ESP8266_ASYNC)
         client->cHttpLine = "";
 #endif
+
+        client->pingInterval           = _pingInterval;
+        client->pongTimeout            = _pongTimeout;
+        client->disconnectTimeoutCount = _disconnectTimeoutCount;
     }
 
 #ifdef ESP8266
     randomSeed(RANDOM_REG32);
 #elif defined(ESP32)
-    #define DR_REG_RNG_BASE 0x3ff75144
+#define DR_REG_RNG_BASE 0x3ff75144
     randomSeed(READ_PERI_REG(DR_REG_RNG_BASE));
 #else
     // TODO find better seed
@@ -110,28 +117,29 @@ void WebSocketsServer::begin(void) {
 }
 
 void WebSocketsServer::close(void) {
-	_runnning = false;
-	 disconnect();
+    _runnning = false;
+    disconnect();
 
-#if (WEBSOCKETS_NETWORK_TYPE == NETWORK_ESP8266)
+#if(WEBSOCKETS_NETWORK_TYPE == NETWORK_ESP8266)
     _server->close();
-#elif (WEBSOCKETS_NETWORK_TYPE == NETWORK_ESP32) || (WEBSOCKETS_NETWORK_TYPE == NETWORK_ESP8266_ASYNC)
+#elif(WEBSOCKETS_NETWORK_TYPE == NETWORK_ESP32) || (WEBSOCKETS_NETWORK_TYPE == NETWORK_ESP8266_ASYNC)
     _server->end();
 #else
     // TODO how to close server?
 #endif
-
 }
 
-#if (WEBSOCKETS_NETWORK_TYPE != NETWORK_ESP8266_ASYNC)
+#if(WEBSOCKETS_NETWORK_TYPE != NETWORK_ESP8266_ASYNC)
 /**
  * called in arduino loop
  */
 void WebSocketsServer::loop(void) {
-	if(_runnning) {
-		handleNewClients();
-		handleClientData();
-	}
+    if(_runnning) {
+        WEBSOCKETS_YIELD();
+        handleNewClients();
+        WEBSOCKETS_YIELD();
+        handleClientData();
+    }
 }
 #endif
 
@@ -150,21 +158,20 @@ void WebSocketsServer::onEvent(WebSocketServerEvent cbEvent) {
  * @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;
+    WebSocketServerHttpHeaderValFunc validationFunc,
+    const char * mandatoryHttpHeaders[],
+    size_t mandatoryHttpHeaderCount) {
+    _httpHeaderValidationFunc = validationFunc;
 
-	if (_mandatoryHttpHeaders)
-		delete[] _mandatoryHttpHeaders;
+    if(_mandatoryHttpHeaders)
+        delete[] _mandatoryHttpHeaders;
 
-	_mandatoryHttpHeaderCount = mandatoryHttpHeaderCount;
-	_mandatoryHttpHeaders = new String[_mandatoryHttpHeaderCount];
+    _mandatoryHttpHeaderCount = mandatoryHttpHeaderCount;
+    _mandatoryHttpHeaders     = new String[_mandatoryHttpHeaderCount];
 
-	for (size_t i = 0; i < _mandatoryHttpHeaderCount; i++) {
-		_mandatoryHttpHeaders[i] = mandatoryHttpHeaders[i];
-	}
+    for(size_t i = 0; i < _mandatoryHttpHeaderCount; i++) {
+        _mandatoryHttpHeaders[i] = mandatoryHttpHeaders[i];
+    }
 }
 
 /*
@@ -180,29 +187,29 @@ bool WebSocketsServer::sendTXT(uint8_t num, uint8_t * payload, size_t length, bo
         return false;
     }
     if(length == 0) {
-        length = strlen((const char *) payload);
+        length = strlen((const char *)payload);
     }
     WSclient_t * client = &_clients[num];
     if(clientIsConnected(client)) {
-        return sendFrame(client, WSop_text, payload, length, false, true, headerToPayload);
+        return sendFrame(client, WSop_text, payload, length, true, headerToPayload);
     }
     return false;
 }
 
 bool WebSocketsServer::sendTXT(uint8_t num, const uint8_t * payload, size_t length) {
-    return sendTXT(num, (uint8_t *) payload, length);
+    return sendTXT(num, (uint8_t *)payload, length);
 }
 
 bool WebSocketsServer::sendTXT(uint8_t num, char * payload, size_t length, bool headerToPayload) {
-    return sendTXT(num, (uint8_t *) payload, length, headerToPayload);
+    return sendTXT(num, (uint8_t *)payload, length, headerToPayload);
 }
 
 bool WebSocketsServer::sendTXT(uint8_t num, const char * payload, size_t length) {
-    return sendTXT(num, (uint8_t *) payload, length);
+    return sendTXT(num, (uint8_t *)payload, length);
 }
 
 bool WebSocketsServer::sendTXT(uint8_t num, String & payload) {
-    return sendTXT(num, (uint8_t *) payload.c_str(), payload.length());
+    return sendTXT(num, (uint8_t *)payload.c_str(), payload.length());
 }
 
 /**
@@ -216,37 +223,35 @@ bool WebSocketsServer::broadcastTXT(uint8_t * payload, size_t length, bool heade
     WSclient_t * client;
     bool ret = true;
     if(length == 0) {
-        length = strlen((const char *) payload);
+        length = strlen((const char *)payload);
     }
 
     for(uint8_t i = 0; i < WEBSOCKETS_SERVER_CLIENT_MAX; i++) {
         client = &_clients[i];
         if(clientIsConnected(client)) {
-            if(!sendFrame(client, WSop_text, payload, length, false, true, headerToPayload)) {
+            if(!sendFrame(client, WSop_text, payload, length, true, headerToPayload)) {
                 ret = false;
             }
         }
-#if (WEBSOCKETS_NETWORK_TYPE == NETWORK_ESP8266)
-        delay(0);
-#endif
+        WEBSOCKETS_YIELD();
     }
     return ret;
 }
 
 bool WebSocketsServer::broadcastTXT(const uint8_t * payload, size_t length) {
-    return broadcastTXT((uint8_t *) payload, length);
+    return broadcastTXT((uint8_t *)payload, length);
 }
 
 bool WebSocketsServer::broadcastTXT(char * payload, size_t length, bool headerToPayload) {
-    return broadcastTXT((uint8_t *) payload, length, headerToPayload);
+    return broadcastTXT((uint8_t *)payload, length, headerToPayload);
 }
 
 bool WebSocketsServer::broadcastTXT(const char * payload, size_t length) {
-    return broadcastTXT((uint8_t *) payload, length);
+    return broadcastTXT((uint8_t *)payload, length);
 }
 
 bool WebSocketsServer::broadcastTXT(String & payload) {
-    return broadcastTXT((uint8_t *) payload.c_str(), payload.length());
+    return broadcastTXT((uint8_t *)payload.c_str(), payload.length());
 }
 
 /**
@@ -263,13 +268,13 @@ bool WebSocketsServer::sendBIN(uint8_t num, uint8_t * payload, size_t length, bo
     }
     WSclient_t * client = &_clients[num];
     if(clientIsConnected(client)) {
-        return sendFrame(client, WSop_binary, payload, length, false, true, headerToPayload);
+        return sendFrame(client, WSop_binary, payload, length, true, headerToPayload);
     }
     return false;
 }
 
 bool WebSocketsServer::sendBIN(uint8_t num, const uint8_t * payload, size_t length) {
-    return sendBIN(num, (uint8_t *) payload, length);
+    return sendBIN(num, (uint8_t *)payload, length);
 }
 
 /**
@@ -285,22 +290,19 @@ bool WebSocketsServer::broadcastBIN(uint8_t * payload, size_t length, bool heade
     for(uint8_t i = 0; i < WEBSOCKETS_SERVER_CLIENT_MAX; i++) {
         client = &_clients[i];
         if(clientIsConnected(client)) {
-            if(!sendFrame(client, WSop_binary, payload, length, false, true, headerToPayload)) {
+            if(!sendFrame(client, WSop_binary, payload, length, true, headerToPayload)) {
                 ret = false;
             }
         }
-#if (WEBSOCKETS_NETWORK_TYPE == NETWORK_ESP8266)
-        delay(0);
-#endif
+        WEBSOCKETS_YIELD();
     }
     return ret;
 }
 
 bool WebSocketsServer::broadcastBIN(const uint8_t * payload, size_t length) {
-    return broadcastBIN((uint8_t *) payload, length);
+    return broadcastBIN((uint8_t *)payload, length);
 }
 
-
 /**
  * sends a WS ping to Client
  * @param num uint8_t client id
@@ -320,7 +322,7 @@ bool WebSocketsServer::sendPing(uint8_t num, uint8_t * payload, size_t length) {
 }
 
 bool WebSocketsServer::sendPing(uint8_t num, String & payload) {
-    return sendPing(num, (uint8_t *) payload.c_str(), payload.length());
+    return sendPing(num, (uint8_t *)payload.c_str(), payload.length());
 }
 
 /**
@@ -339,18 +341,15 @@ bool WebSocketsServer::broadcastPing(uint8_t * payload, size_t length) {
                 ret = false;
             }
         }
-#if (WEBSOCKETS_NETWORK_TYPE == NETWORK_ESP8266)
-        delay(0);
-#endif
+        WEBSOCKETS_YIELD();
     }
     return ret;
 }
 
 bool WebSocketsServer::broadcastPing(String & payload) {
-    return broadcastPing((uint8_t *) payload.c_str(), payload.length());
+    return broadcastPing((uint8_t *)payload.c_str(), payload.length());
 }
 
-
 /**
  * disconnect all clients
  */
@@ -378,7 +377,6 @@ void WebSocketsServer::disconnect(uint8_t num) {
     }
 }
 
-
 /*
  * set the Authorization for the http request
  * @param user const char *
@@ -410,18 +408,18 @@ void WebSocketsServer::setAuthorization(const char * auth) {
 int WebSocketsServer::connectedClients(bool ping) {
     WSclient_t * client;
     int count = 0;
-	for(uint8_t i = 0; i < WEBSOCKETS_SERVER_CLIENT_MAX; i++) {
-		client = &_clients[i];
-		if(client->status == WSC_CONNECTED) {
-			if(ping != true || sendPing(i)) {
-				count++;
-			}
-		}
-	}
+    for(uint8_t i = 0; i < WEBSOCKETS_SERVER_CLIENT_MAX; i++) {
+        client = &_clients[i];
+        if(client->status == WSC_CONNECTED) {
+            if(ping != true || sendPing(i)) {
+                count++;
+            }
+        }
+    }
     return count;
 }
 
-#if (WEBSOCKETS_NETWORK_TYPE == NETWORK_ESP8266) || (WEBSOCKETS_NETWORK_TYPE == NETWORK_ESP8266_ASYNC) || (WEBSOCKETS_NETWORK_TYPE == NETWORK_ESP32)
+#if(WEBSOCKETS_NETWORK_TYPE == NETWORK_ESP8266) || (WEBSOCKETS_NETWORK_TYPE == NETWORK_ESP8266_ASYNC) || (WEBSOCKETS_NETWORK_TYPE == NETWORK_ESP32)
 /**
  * get an IP for a client
  * @param num uint8_t client id
@@ -455,42 +453,48 @@ bool WebSocketsServer::newClient(WEBSOCKETS_NETWORK_CLASS * TCPclient) {
 
         // state is not connected or tcp connection is lost
         if(!clientIsConnected(client)) {
-
             client->tcp = TCPclient;
 
-#if (WEBSOCKETS_NETWORK_TYPE == NETWORK_ESP8266) || (WEBSOCKETS_NETWORK_TYPE == NETWORK_ESP32)
+#if(WEBSOCKETS_NETWORK_TYPE == NETWORK_ESP8266) || (WEBSOCKETS_NETWORK_TYPE == NETWORK_ESP32)
             client->isSSL = false;
             client->tcp->setNoDelay(true);
 #endif
-#if (WEBSOCKETS_NETWORK_TYPE != NETWORK_ESP8266_ASYNC)
+#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) || (WEBSOCKETS_NETWORK_TYPE == NETWORK_ESP32)
+#if(WEBSOCKETS_NETWORK_TYPE == NETWORK_ESP8266) || (WEBSOCKETS_NETWORK_TYPE == NETWORK_ESP8266_ASYNC) || (WEBSOCKETS_NETWORK_TYPE == NETWORK_ESP32)
+#ifndef NODEBUG_WEBSOCKETS
             IPAddress ip = client->tcp->remoteIP();
+#endif
             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)
+#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;
+                    *sl            = NULL;
                 }
                 return true;
-            },  this, std::placeholders::_1, client));
-
+            },
+                this, std::placeholders::_1, client));
 
             client->tcp->readStringUntil('\n', &(client->cHttpLine), std::bind(&WebSocketsServer::handleHeader, this, client, &(client->cHttpLine)));
 #endif
 
+            client->pingInterval           = _pingInterval;
+            client->pongTimeout            = _pongTimeout;
+            client->disconnectTimeoutCount = _disconnectTimeoutCount;
+            client->lastPing               = millis();
+            client->pongReceived           = false;
+
             return true;
             break;
         }
@@ -518,15 +522,18 @@ void WebSocketsServer::messageReceived(WSclient_t * client, WSopcode_t opcode, u
         case WSop_continuation:
             type = fin ? WStype_FRAGMENT_FIN : WStype_FRAGMENT;
             break;
-        case WSop_close:
         case WSop_ping:
+            type = WStype_PING;
+            break;
         case WSop_pong:
+            type = WStype_PONG;
+            break;
+        case WSop_close:
         default:
             break;
     }
 
     runCbEvent(client->num, type, payload, length);
-
 }
 
 /**
@@ -534,9 +541,7 @@ void WebSocketsServer::messageReceived(WSclient_t * client, WSopcode_t opcode, u
  * @param client WSclient_t *  ptr to the client struct
  */
 void WebSocketsServer::clientDisconnect(WSclient_t * client) {
-
-
-#if (WEBSOCKETS_NETWORK_TYPE == NETWORK_ESP8266) || (WEBSOCKETS_NETWORK_TYPE == NETWORK_ESP32)
+#if(WEBSOCKETS_NETWORK_TYPE == NETWORK_ESP8266) || (WEBSOCKETS_NETWORK_TYPE == NETWORK_ESP32)
     if(client->isSSL && client->ssl) {
         if(client->ssl->connected()) {
             client->ssl->flush();
@@ -550,12 +555,12 @@ void WebSocketsServer::clientDisconnect(WSclient_t * client) {
 
     if(client->tcp) {
         if(client->tcp->connected()) {
-#if (WEBSOCKETS_NETWORK_TYPE != NETWORK_ESP8266_ASYNC)
+#if(WEBSOCKETS_NETWORK_TYPE != NETWORK_ESP8266_ASYNC)
             client->tcp->flush();
 #endif
             client->tcp->stop();
         }
-#if (WEBSOCKETS_NETWORK_TYPE == NETWORK_ESP8266_ASYNC)
+#if(WEBSOCKETS_NETWORK_TYPE == NETWORK_ESP8266_ASYNC)
         client->status = WSC_NOT_CONNECTED;
 #else
         delete client->tcp;
@@ -563,16 +568,16 @@ void WebSocketsServer::clientDisconnect(WSclient_t * client) {
         client->tcp = NULL;
     }
 
-    client->cUrl = "";
-    client->cKey = "";
-    client->cProtocol = "";
-    client->cVersion = 0;
-    client->cIsUpgrade = false;
+    client->cUrl         = "";
+    client->cKey         = "";
+    client->cProtocol    = "";
+    client->cVersion     = 0;
+    client->cIsUpgrade   = false;
     client->cIsWebsocket = false;
 
     client->cWsRXsize = 0;
 
-#if (WEBSOCKETS_NETWORK_TYPE == NETWORK_ESP8266_ASYNC)
+#if(WEBSOCKETS_NETWORK_TYPE == NETWORK_ESP8266_ASYNC)
     client->cHttpLine = "";
 #endif
 
@@ -581,7 +586,6 @@ void WebSocketsServer::clientDisconnect(WSclient_t * client) {
     DEBUG_WEBSOCKETS("[WS-Server][%d] client disconnected.\n", client->num);
 
     runCbEvent(client->num, WStype_DISCONNECTED, NULL, 0);
-
 }
 
 /**
@@ -590,7 +594,6 @@ void WebSocketsServer::clientDisconnect(WSclient_t * client) {
  * @return true = connected
  */
 bool WebSocketsServer::clientIsConnected(WSclient_t * client) {
-
     if(!client->tcp) {
         return false;
     }
@@ -616,22 +619,21 @@ bool WebSocketsServer::clientIsConnected(WSclient_t * client) {
 
     return false;
 }
-#if (WEBSOCKETS_NETWORK_TYPE != NETWORK_ESP8266_ASYNC)
+#if(WEBSOCKETS_NETWORK_TYPE != NETWORK_ESP8266_ASYNC)
 /**
  * Handle incoming Connection Request
  */
 void WebSocketsServer::handleNewClients(void) {
-
-#if (WEBSOCKETS_NETWORK_TYPE == NETWORK_ESP8266) || (WEBSOCKETS_NETWORK_TYPE == NETWORK_ESP32)
+#if(WEBSOCKETS_NETWORK_TYPE == NETWORK_ESP8266) || (WEBSOCKETS_NETWORK_TYPE == NETWORK_ESP32)
     while(_server->hasClient()) {
 #endif
         bool ok = false;
 
-#if (WEBSOCKETS_NETWORK_TYPE == NETWORK_ESP8266) || (WEBSOCKETS_NETWORK_TYPE == NETWORK_ESP32)
+#if(WEBSOCKETS_NETWORK_TYPE == NETWORK_ESP8266) || (WEBSOCKETS_NETWORK_TYPE == NETWORK_ESP32)
         // store new connection
         WEBSOCKETS_NETWORK_CLASS * tcpClient = new WEBSOCKETS_NETWORK_CLASS(_server->available());
 #else
-        WEBSOCKETS_NETWORK_CLASS * tcpClient = new WEBSOCKETS_NETWORK_CLASS(_server->available());
+    WEBSOCKETS_NETWORK_CLASS * tcpClient = new WEBSOCKETS_NETWORK_CLASS(_server->available());
 #endif
 
         if(!tcpClient) {
@@ -643,28 +645,27 @@ void WebSocketsServer::handleNewClients(void) {
 
         if(!ok) {
             // no free space to handle client
-#if (WEBSOCKETS_NETWORK_TYPE == NETWORK_ESP8266) || (WEBSOCKETS_NETWORK_TYPE == NETWORK_ESP32)
+#if(WEBSOCKETS_NETWORK_TYPE == NETWORK_ESP8266) || (WEBSOCKETS_NETWORK_TYPE == NETWORK_ESP32)
+#ifndef NODEBUG_WEBSOCKETS
             IPAddress ip = tcpClient->remoteIP();
+#endif
             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");
+        DEBUG_WEBSOCKETS("[WS-Server] no free space new client\n");
 #endif
             tcpClient->stop();
         }
 
-#if (WEBSOCKETS_NETWORK_TYPE == NETWORK_ESP8266) || (WEBSOCKETS_NETWORK_TYPE == NETWORK_ESP32)
-        delay(0);
+        WEBSOCKETS_YIELD();
+#if(WEBSOCKETS_NETWORK_TYPE == NETWORK_ESP8266) || (WEBSOCKETS_NETWORK_TYPE == NETWORK_ESP32)
     }
 #endif
-
 }
 
-
 /**
  * Handel incomming data from Client
  */
 void WebSocketsServer::handleClientData(void) {
-
     WSclient_t * client;
     for(uint8_t i = 0; i < WEBSOCKETS_SERVER_CLIENT_MAX; i++) {
         client = &_clients[i];
@@ -673,12 +674,10 @@ void WebSocketsServer::handleClientData(void) {
             if(len > 0) {
                 //DEBUG_WEBSOCKETS("[WS-Server][%d][handleClientData] len: %d\n", client->num, len);
                 switch(client->status) {
-                    case WSC_HEADER:
-                    {
+                    case WSC_HEADER: {
                         String headerLine = client->tcp->readStringUntil('\n');
                         handleHeader(client, &headerLine);
-                    }
-                        break;
+                    } break;
                     case WSC_CONNECTED:
                         WebSockets::handleWebsocket(client);
                         break;
@@ -687,10 +686,11 @@ void WebSocketsServer::handleClientData(void) {
                         break;
                 }
             }
+
+            handleHBPing(client);
+            handleHBTimeout(client);
         }
-#if (WEBSOCKETS_NETWORK_TYPE == NETWORK_ESP8266)
-        delay(0);
-#endif
+        WEBSOCKETS_YIELD();
     }
 }
 #endif
@@ -700,84 +700,80 @@ void WebSocketsServer::handleClientData(void) {
  * @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;
+    for(size_t i = 0; i < _mandatoryHttpHeaderCount; i++) {
+        if(_mandatoryHttpHeaders[i].equalsIgnoreCase(headerName))
+            return true;
+    }
+    return false;
 }
 
-
 /**
  * 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, String * headerLine) {
+    static const char * NEW_LINE = "\r\n";
 
-	static const char * NEW_LINE = "\r\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 ")) {
+            // cut URL out
+            client->cUrl = headerLine->substring(4, headerLine->indexOf(' ', 4));
 
-		// websocket requests always start with GET see rfc6455
-		if(headerLine->startsWith("GET ")) {
+            //reset non-websocket http header validation state for this client
+            client->cHttpHeadersValid      = true;
+            client->cMandatoryHeadersCount = 0;
 
-			// cut URL out
-			client->cUrl = headerLine->substring(4, headerLine->indexOf(' ', 4));
+        } else if(headerLine->indexOf(':') >= 0) {
+            String headerName  = headerLine->substring(0, headerLine->indexOf(':'));
+            String headerValue = headerLine->substring(headerLine->indexOf(':') + 1);
 
-			//reset non-websocket http header validation state for this client
-			client->cHttpHeadersValid = true;
-			client->cMandatoryHeadersCount = 0;
+            // remove space in the beginning (RFC2616)
+            if(headerValue[0] == ' ') {
+                headerValue.remove(0, 1);
+            }
 
-		} else if(headerLine->indexOf(':')) {
-			String headerName = headerLine->substring(0, headerLine->indexOf(':'));
-			String headerValue = headerLine->substring(headerLine->indexOf(':') + 1);
+            if(headerName.equalsIgnoreCase(WEBSOCKETS_STRING("Connection"))) {
+                headerValue.toLowerCase();
+                if(headerValue.indexOf(WEBSOCKETS_STRING("upgrade")) >= 0) {
+                    client->cIsUpgrade = true;
+                }
+            } else if(headerName.equalsIgnoreCase(WEBSOCKETS_STRING("Upgrade"))) {
+                if(headerValue.equalsIgnoreCase(WEBSOCKETS_STRING("websocket"))) {
+                    client->cIsWebsocket = true;
+                }
+            } else if(headerName.equalsIgnoreCase(WEBSOCKETS_STRING("Sec-WebSocket-Version"))) {
+                client->cVersion = headerValue.toInt();
+            } else if(headerName.equalsIgnoreCase(WEBSOCKETS_STRING("Sec-WebSocket-Key"))) {
+                client->cKey = headerValue;
+                client->cKey.trim();    // see rfc6455
+            } else if(headerName.equalsIgnoreCase(WEBSOCKETS_STRING("Sec-WebSocket-Protocol"))) {
+                client->cProtocol = headerValue;
+            } else if(headerName.equalsIgnoreCase(WEBSOCKETS_STRING("Sec-WebSocket-Extensions"))) {
+                client->cExtensions = headerValue;
+            } else if(headerName.equalsIgnoreCase(WEBSOCKETS_STRING("Authorization"))) {
+                client->base64Authorization = headerValue;
+            } else {
+                client->cHttpHeadersValid &= execHttpHeaderValidation(headerName, headerValue);
+                if(_mandatoryHttpHeaderCount > 0 && hasMandatoryHeader(headerName)) {
+                    client->cMandatoryHeadersCount++;
+                }
+            }
 
-			// remove space in the beginning (RFC2616)
-			if(headerValue[0] == ' ') {
-				headerValue.remove(0, 1);
-			}
-
-			if(headerName.equalsIgnoreCase(WEBSOCKETS_STRING("Connection"))) {
-				headerValue.toLowerCase();
-				if(headerValue.indexOf(WEBSOCKETS_STRING("upgrade")) >= 0) {
-					client->cIsUpgrade = true;
-				}
-			} else if(headerName.equalsIgnoreCase(WEBSOCKETS_STRING("Upgrade"))) {
-				if(headerValue.equalsIgnoreCase(WEBSOCKETS_STRING("websocket"))) {
-					client->cIsWebsocket = true;
-				}
-			} else if(headerName.equalsIgnoreCase(WEBSOCKETS_STRING("Sec-WebSocket-Version"))) {
-				client->cVersion = headerValue.toInt();
-			} else if(headerName.equalsIgnoreCase(WEBSOCKETS_STRING("Sec-WebSocket-Key"))) {
-				client->cKey = headerValue;
-				client->cKey.trim(); // see rfc6455
-			} else if(headerName.equalsIgnoreCase(WEBSOCKETS_STRING("Sec-WebSocket-Protocol"))) {
-				client->cProtocol = headerValue;
-			} else if(headerName.equalsIgnoreCase(WEBSOCKETS_STRING("Sec-WebSocket-Extensions"))) {
-				client->cExtensions = headerValue;
-			} else if(headerName.equalsIgnoreCase(WEBSOCKETS_STRING("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());
-		}
+        } else {
+            DEBUG_WEBSOCKETS("[WS-Client][handleHeader] Header error (%s)\n", headerLine->c_str());
+        }
 
         (*headerLine) = "";
-#if (WEBSOCKETS_NETWORK_TYPE == NETWORK_ESP8266_ASYNC)
+#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]  - cURL: %s\n", client->num, client->cUrl.c_str());
         DEBUG_WEBSOCKETS("[WS-Server][%d][handleHeader]  - cIsUpgrade: %d\n", client->num, client->cIsUpgrade);
@@ -792,36 +788,35 @@ void WebSocketsServer::handleHeader(WSclient_t * client, String * headerLine) {
 
         bool ok = (client->cIsUpgrade && client->cIsWebsocket);
 
-		if(ok) {
-			if(client->cUrl.length() == 0) {
-				ok = false;
-			}
-			if(client->cKey.length() == 0) {
+        if(ok) {
+            if(client->cUrl.length() == 0) {
+                ok = false;
+            }
+            if(client->cKey.length() == 0) {
                 ok = false;
             }
             if(client->cVersion != 13) {
                 ok = false;
             }
             if(!client->cHttpHeadersValid) {
-            	ok = false;
+                ok = false;
             }
-            if (client->cMandatoryHeadersCount != _mandatoryHttpHeaderCount) {
-            	ok = false;
+            if(client->cMandatoryHeadersCount != _mandatoryHttpHeaderCount) {
+                ok = false;
             }
         }
 
         if(_base64Authorization.length() > 0) {
-			String auth = WEBSOCKETS_STRING("Basic ");
-			auth += _base64Authorization;
-			if(auth != client->base64Authorization) {
-				DEBUG_WEBSOCKETS("[WS-Server][%d][handleHeader] HTTP Authorization failed!\n", client->num);
-				handleAuthorizationFailed(client);
-				return;
-			}
+            String auth = WEBSOCKETS_STRING("Basic ");
+            auth += _base64Authorization;
+            if(auth != client->base64Authorization) {
+                DEBUG_WEBSOCKETS("[WS-Server][%d][handleHeader] HTTP Authorization failed!\n", client->num);
+                handleAuthorizationFailed(client);
+                return;
+            }
         }
 
         if(ok) {
-
             DEBUG_WEBSOCKETS("[WS-Server][%d][handleHeader] Websocket connection incoming.\n", client->num);
 
             // generate Sec-WebSocket-Accept key
@@ -831,37 +826,38 @@ void WebSocketsServer::handleHeader(WSclient_t * client, String * headerLine) {
 
             client->status = WSC_CONNECTED;
 
-            String handshake = WEBSOCKETS_STRING("HTTP/1.1 101 Switching Protocols\r\n"
-                    "Server: arduino-WebSocketsServer\r\n"
-                    "Upgrade: websocket\r\n"
-                    "Connection: Upgrade\r\n"
-                    "Sec-WebSocket-Version: 13\r\n"
-                    "Sec-WebSocket-Accept: ");
-			handshake += sKey + NEW_LINE;
+            String handshake = WEBSOCKETS_STRING(
+                "HTTP/1.1 101 Switching Protocols\r\n"
+                "Server: arduino-WebSocketsServer\r\n"
+                "Upgrade: websocket\r\n"
+                "Connection: Upgrade\r\n"
+                "Sec-WebSocket-Version: 13\r\n"
+                "Sec-WebSocket-Accept: ");
+            handshake += sKey + NEW_LINE;
 
             if(_origin.length() > 0) {
                 handshake += WEBSOCKETS_STRING("Access-Control-Allow-Origin: ");
-                handshake +=_origin + NEW_LINE;
+                handshake += _origin + NEW_LINE;
             }
 
             if(client->cProtocol.length() > 0) {
-            	handshake += WEBSOCKETS_STRING("Sec-WebSocket-Protocol: ");
-            	handshake +=_protocol + NEW_LINE;
+                handshake += WEBSOCKETS_STRING("Sec-WebSocket-Protocol: ");
+                handshake += _protocol + NEW_LINE;
             }
 
             // header end
             handshake += NEW_LINE;
 
-            DEBUG_WEBSOCKETS("[WS-Server][%d][handleHeader] handshake %s",  client->num, (uint8_t*)handshake.c_str());
+            DEBUG_WEBSOCKETS("[WS-Server][%d][handleHeader] handshake %s", client->num, (uint8_t *)handshake.c_str());
 
-            write(client, (uint8_t*)handshake.c_str(), handshake.length());
+            write(client, (uint8_t *)handshake.c_str(), handshake.length());
 
             headerDone(client);
 
             // send ping
             WebSockets::sendFrame(client, WSop_ping);
 
-            runCbEvent(client->num, WStype_CONNECTED, (uint8_t *) client->cUrl.c_str(), client->cUrl.length());
+            runCbEvent(client->num, WStype_CONNECTED, (uint8_t *)client->cUrl.c_str(), client->cUrl.length());
 
         } else {
             handleNonWebsocketConnection(client);
@@ -869,5 +865,49 @@ void WebSocketsServer::handleHeader(WSclient_t * client, String * headerLine) {
     }
 }
 
+/**
+ * send heartbeat ping to server in set intervals
+ */
+void WebSocketsServer::handleHBPing(WSclient_t * client) {
+    if(client->pingInterval == 0)
+        return;
+    uint32_t pi = millis() - client->lastPing;
+    if(pi > client->pingInterval) {
+        DEBUG_WEBSOCKETS("[WS-Server][%d] sending HB ping\n", client->num);
+        if(sendPing(client->num)) {
+            client->lastPing     = millis();
+            client->pongReceived = false;
+        }
+    }
+}
 
+/**
+ * enable ping/pong heartbeat process
+ * @param pingInterval uint32_t how often ping will be sent
+ * @param pongTimeout uint32_t millis after which pong should timout if not received
+ * @param disconnectTimeoutCount uint8_t how many timeouts before disconnect, 0=> do not disconnect
+ */
+void WebSocketsServer::enableHeartbeat(uint32_t pingInterval, uint32_t pongTimeout, uint8_t disconnectTimeoutCount) {
+    _pingInterval           = pingInterval;
+    _pongTimeout            = pongTimeout;
+    _disconnectTimeoutCount = disconnectTimeoutCount;
 
+    WSclient_t * client;
+    for(uint8_t i = 0; i < WEBSOCKETS_SERVER_CLIENT_MAX; i++) {
+        client = &_clients[i];
+        WebSockets::enableHeartbeat(client, pingInterval, pongTimeout, disconnectTimeoutCount);
+    }
+}
+
+/**
+ * disable ping/pong heartbeat process
+ */
+void WebSocketsServer::disableHeartbeat() {
+    _pingInterval = 0;
+
+    WSclient_t * client;
+    for(uint8_t i = 0; i < WEBSOCKETS_SERVER_CLIENT_MAX; i++) {
+        client               = &_clients[i];
+        client->pingInterval = 0;
+    }
+}

src/WebSocketsServer.h

@@ -28,160 +28,166 @@
 #include "WebSockets.h"
 
 #ifndef WEBSOCKETS_SERVER_CLIENT_MAX
-#define WEBSOCKETS_SERVER_CLIENT_MAX  (5)
+#define WEBSOCKETS_SERVER_CLIENT_MAX (5)
 #endif
 
-
-
-
-class WebSocketsServer: protected WebSockets {
-public:
-
+class WebSocketsServer : protected 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);
+    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;
+    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, String origin = "", String protocol = "arduino");
-        virtual ~WebSocketsServer(void);
+    WebSocketsServer(uint16_t port, String origin = "", String protocol = "arduino");
+    virtual ~WebSocketsServer(void);
 
-        void begin(void);
-        void close(void);
+    void begin(void);
+    void close(void);
 
-#if (WEBSOCKETS_NETWORK_TYPE != NETWORK_ESP8266_ASYNC)
-        void loop(void);
+#if(WEBSOCKETS_NETWORK_TYPE != NETWORK_ESP8266_ASYNC)
+    void loop(void);
 #else
-        // Async interface not need a loop call
-        void loop(void) __attribute__ ((deprecated)) {}
+    // 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 onEvent(WebSocketServerEvent cbEvent);
+    void onValidateHttpHeader(
+        WebSocketServerHttpHeaderValFunc validationFunc,
+        const char * mandatoryHttpHeaders[],
+        size_t mandatoryHttpHeaderCount);
 
+    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);
 
-        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);
+    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);
 
-        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);
+    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);
 
-        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);
+    bool broadcastBIN(uint8_t * payload, size_t length, bool headerToPayload = false);
+    bool 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 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);
 
-        bool broadcastPing(uint8_t * payload = NULL, size_t length = 0);
-        bool broadcastPing(String & payload);
+    void disconnect(void);
+    void disconnect(uint8_t num);
 
-        void disconnect(void);
-        void disconnect(uint8_t num);
+    void setAuthorization(const char * user, const char * password);
+    void setAuthorization(const char * auth);
 
-        void setAuthorization(const char * user, const char * password);
-        void setAuthorization(const char * auth);
+    int connectedClients(bool ping = false);
 
-        int connectedClients(bool ping = false);
+    void enableHeartbeat(uint32_t pingInterval, uint32_t pongTimeout, uint8_t disconnectTimeoutCount);
+    void disableHeartbeat();
 
-#if (WEBSOCKETS_NETWORK_TYPE == NETWORK_ESP8266) || (WEBSOCKETS_NETWORK_TYPE == NETWORK_ESP8266_ASYNC) || (WEBSOCKETS_NETWORK_TYPE == NETWORK_ESP32)
-        IPAddress remoteIP(uint8_t num);
+#if(WEBSOCKETS_NETWORK_TYPE == NETWORK_ESP8266) || (WEBSOCKETS_NETWORK_TYPE == NETWORK_ESP8266_ASYNC) || (WEBSOCKETS_NETWORK_TYPE == NETWORK_ESP32)
+    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;
+  protected:
+    uint16_t _port;
+    String _origin;
+    String _protocol;
+    String _base64Authorization;    ///< Base64 encoded Auth request
+    String * _mandatoryHttpHeaders;
+    size_t _mandatoryHttpHeaderCount;
 
-        WEBSOCKETS_NETWORK_SERVER_CLASS * _server;
+    WEBSOCKETS_NETWORK_SERVER_CLASS * _server;
 
-        WSclient_t _clients[WEBSOCKETS_SERVER_CLIENT_MAX];
+    WSclient_t _clients[WEBSOCKETS_SERVER_CLIENT_MAX];
 
-        WebSocketServerEvent _cbEvent;
-        WebSocketServerHttpHeaderValFunc _httpHeaderValidationFunc;
+    WebSocketServerEvent _cbEvent;
+    WebSocketServerHttpHeaderValFunc _httpHeaderValidationFunc;
 
-        bool _runnning;
+    bool _runnning;
 
-        bool newClient(WEBSOCKETS_NETWORK_CLASS * TCPclient);
+    uint32_t _pingInterval;
+    uint32_t _pongTimeout;
+    uint8_t _disconnectTimeoutCount;
 
-        void messageReceived(WSclient_t * client, WSopcode_t opcode, uint8_t * payload, size_t length, bool fin);
+    bool newClient(WEBSOCKETS_NETWORK_CLASS * TCPclient);
 
-        void clientDisconnect(WSclient_t * client);
-        bool clientIsConnected(WSclient_t * client);
+    void messageReceived(WSclient_t * client, WSopcode_t opcode, uint8_t * payload, size_t length, bool fin);
 
-#if (WEBSOCKETS_NETWORK_TYPE != NETWORK_ESP8266_ASYNC)
-        void handleNewClients(void);
-        void handleClientData(void);
+    void clientDisconnect(WSclient_t * client);
+    bool clientIsConnected(WSclient_t * client);
+
+#if(WEBSOCKETS_NETWORK_TYPE != NETWORK_ESP8266_ASYNC)
+    void handleNewClients(void);
+    void handleClientData(void);
 #endif
 
-        void handleHeader(WSclient_t * client, String * headerLine);
+    void handleHeader(WSclient_t * client, String * headerLine);
 
-        /**
+    void handleHBPing(WSclient_t * client);    // send ping in specified intervals
+
+    /**
          * 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) {
-            DEBUG_WEBSOCKETS("[WS-Server][%d][handleHeader] no Websocket connection close.\n", client->num);
-            client->tcp->write("HTTP/1.1 400 Bad Request\r\n"
-                    "Server: arduino-WebSocket-Server\r\n"
-                    "Content-Type: text/plain\r\n"
-                    "Content-Length: 32\r\n"
-                    "Connection: close\r\n"
-                    "Sec-WebSocket-Version: 13\r\n"
-                    "\r\n"
-                    "This is a Websocket server only!");
-            clientDisconnect(client);
-        }
+    virtual void handleNonWebsocketConnection(WSclient_t * client) {
+        DEBUG_WEBSOCKETS("[WS-Server][%d][handleHeader] no Websocket connection close.\n", client->num);
+        client->tcp->write(
+            "HTTP/1.1 400 Bad Request\r\n"
+            "Server: arduino-WebSocket-Server\r\n"
+            "Content-Type: text/plain\r\n"
+            "Content-Length: 32\r\n"
+            "Connection: close\r\n"
+            "Sec-WebSocket-Version: 13\r\n"
+            "\r\n"
+            "This is a Websocket server only!");
+        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);
-        }
+    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
          * @param type WStype_t
          * @param payload uint8_t *
          * @param length size_t
          */
-        virtual void runCbEvent(uint8_t num, WStype_t type, uint8_t * payload, size_t length) {
-            if(_cbEvent) {
-                _cbEvent(num, type, payload, length);
-            }
+    virtual void runCbEvent(uint8_t num, WStype_t type, uint8_t * payload, size_t length) {
+        if(_cbEvent) {
+            _cbEvent(num, type, payload, length);
         }
+    }
 
-        /*
+    /*
          * 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
@@ -189,24 +195,21 @@ protected:
          * 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;
+    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:
-        /*
+  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);
-
+    bool hasMandatoryHeader(String headerName);
 };
 
-
-
 #endif /* WEBSOCKETSSERVER_H_ */