Update README.md (#927)

* Update README.md

Updating README to include ESP32 support in client mode

* Update README.md

---------

Co-authored-by: Markus <974709+Links2004@users.noreply.github.com>

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

.github/dependabot.yml

@@ -0,0 +1,11 @@
+# To get started with Dependabot version updates, you'll need to specify which
+# package ecosystems to update and where the package manifests are located.
+# Please see the documentation for all configuration options:
+# https://docs.github.com/code-security/dependabot/dependabot-version-updates/configuration-options-for-the-dependabot.yml-file
+
+version: 2
+updates:
+  - package-ecosystem: "github-actions"
+    directory: "/"
+    schedule:
+      interval: "weekly"

.github/workflows/arduino-lint.yaml

@@ -0,0 +1,10 @@
+name: Arduino library compliance (Lint)
+on: [push, pull_request]
+jobs:
+  lint:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: arduino/arduino-lint-action@v2
+        with:
+          library-manager: update

.github/workflows/compile-arduino_wifinina-examples.yaml

@@ -0,0 +1,69 @@
+name: Compile Arduino WiFiNINA Examples
+
+# See: https://docs.github.com/en/free-pro-team@latest/actions/reference/events-that-trigger-workflows
+on:
+  push:
+    paths:
+      - ".github/workflows/compile-arduino_wifinina-examples.yaml"
+      - "examples/arduino_wifinina/**"
+      - "src/**"
+  pull_request:
+    paths:
+      - ".github/workflows/compile-arduino_wifinina-examples.yaml"
+      - "examples/arduino_wifinina/**"
+      - "src/**"
+  schedule:
+    # Run every Tuesday at 8 AM UTC to catch breakage caused by changes to external resources (libraries, platforms).
+    - cron: "0 8 * * TUE"
+  workflow_dispatch:
+  repository_dispatch:
+
+jobs:
+  build:
+    name: ${{ matrix.board.fqbn }}
+    runs-on: ubuntu-latest
+
+    env:
+      SKETCHES_REPORTS_PATH: sketches-reports
+
+    strategy:
+      fail-fast: false
+
+      matrix:
+        board:
+          - fqbn: arduino:samd:mkrwifi1010
+            platforms: |
+              - name: arduino:samd
+            artifact-name-suffix: arduino-samd-mkrwifi1010
+            libraries: |
+              - name: WiFiNINA
+          - fqbn: arduino:samd:nano_33_iot
+            platforms: |
+              - name: arduino:samd
+            artifact-name-suffix: arduino-samd-nano_33_iot
+            libraries: |
+              - name: WiFiNINA
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v4
+
+      - name: Compile examples
+        uses: arduino/compile-sketches@v1
+        with:
+          fqbn: ${{ matrix.board.fqbn }}
+          platforms: ${{ matrix.board.platforms }}
+          libraries: |
+            # Install the library from the local path.
+            - source-path: ./
+            ${{ matrix.board.libraries }}
+          sketch-paths: |
+            - examples/arduino_wifinina/arduino_wifinina.ino
+          enable-deltas-report: true
+          sketches-report-path: ${{ env.SKETCHES_REPORTS_PATH }}
+
+      - name: Save sketches report as workflow artifact
+        uses: actions/upload-artifact@v4
+        with:
+          if-no-files-found: error
+          path: ${{ env.SKETCHES_REPORTS_PATH }}
+          name: sketches-report-${{ matrix.board.artifact-name-suffix }}

.github/workflows/compile-seeed-studio-examples.yaml

@@ -0,0 +1,81 @@
+name: Compile SeedStudio Examples
+
+# See: https://docs.github.com/en/free-pro-team@latest/actions/reference/events-that-trigger-workflows
+on:
+  push:
+    paths:
+      - ".github/workflows/compile-seeed-studio-examples.yaml"
+      - "examples/seeed-studio/**"
+      - "src/**"
+  pull_request:
+    paths:
+      - ".github/workflows/compile-seeed-studio-examples.yaml"
+      - "examples/seeed-studio/**"
+      - "src/**"
+  schedule:
+    # Run every Tuesday at 8 AM UTC to catch breakage caused by changes to external resources (libraries, platforms).
+    - cron: "0 8 * * TUE"
+  workflow_dispatch:
+  repository_dispatch:
+
+jobs:
+  build:
+    name: ${{ matrix.board.fqbn }}
+    runs-on: ubuntu-latest
+
+    env:
+      SKETCHES_REPORTS_PATH: sketches-reports
+
+    strategy:
+      fail-fast: false
+
+      matrix:
+        board:
+          - fqbn: Seeeduino:samd:seeed_XIAO_m0:usbstack=arduino,debug=off
+            platforms: |
+              - name: Seeeduino:samd
+                source-url: https://files.seeedstudio.com/arduino/package_seeeduino_boards_index.json
+            libraries: |
+              - name: Seeed Arduino rpcWiFi
+              - name: Seeed Arduino rpcUnified
+              - name: Seeed_Arduino_mbedtls
+              - name: Seeed Arduino FS
+              - name: Seeed Arduino SFUD
+            artifact-name-suffix: seeeduino-xia0
+          - fqbn: Seeeduino:samd:seeed_wio_terminal
+            platforms: |
+              - name: Seeeduino:samd
+                source-url: https://files.seeedstudio.com/arduino/package_seeeduino_boards_index.json
+            libraries: |
+              - name: Seeed Arduino rpcWiFi
+              - name: Seeed Arduino rpcUnified
+              - name: Seeed_Arduino_mbedtls
+              - name: Seeed Arduino FS
+              - name: Seeed Arduino SFUD
+            artifact-name-suffix: seeeduino-wio_terminal
+
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v4
+
+      - name: Compile examples
+        uses: arduino/compile-sketches@v1
+        with:
+          github-token: ${{ secrets.GITHUB_TOKEN }}
+          fqbn: ${{ matrix.board.fqbn }}
+          platforms: ${{ matrix.board.platforms }}
+          libraries: |
+            # Install the library from the local path.
+            - source-path: ./
+            ${{ matrix.board.libraries }}
+          sketch-paths: |
+            - examples/seeed-studio/xio-wio-terminal/WebSocketClient
+          enable-deltas-report: true
+          sketches-report-path: ${{ env.SKETCHES_REPORTS_PATH }}
+
+      - name: Save sketches report as workflow artifact
+        uses: actions/upload-artifact@v4
+        with:
+          if-no-files-found: error
+          path: ${{ env.SKETCHES_REPORTS_PATH }}
+          name: sketches-report-${{ matrix.board.artifact-name-suffix }}

.github/workflows/compile-unor4wifi-examples.yaml

@@ -0,0 +1,60 @@
+name: Compile Arduino UNO R4 WiFi Examples
+
+# See: https://docs.github.com/en/free-pro-team@latest/actions/reference/events-that-trigger-workflows
+on:
+  push:
+    paths:
+      - ".github/workflows/compile-unor4wifi-examples.yaml"
+      - "examples/arduino_renesas/**"
+      - "src/**"
+  pull_request:
+    paths:
+      - ".github/workflows/compile-unor4wifi-examples.yaml"
+      - "examples/arduino_renesas/**"
+      - "src/**"
+  schedule:
+    # Run every Tuesday at 8 AM UTC to catch breakage caused by changes to external resources (libraries, platforms).
+    - cron: "0 8 * * TUE"
+  workflow_dispatch:
+  repository_dispatch:
+
+jobs:
+  build:
+    name: ${{ matrix.board.fqbn }}
+    runs-on: ubuntu-latest
+
+    env:
+      SKETCHES_REPORTS_PATH: sketches-reports
+
+    strategy:
+      fail-fast: false
+
+      matrix:
+        board:
+          - fqbn: arduino:renesas_uno:unor4wifi
+            platforms: |
+              - name: arduino:renesas_uno
+
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v4
+
+      - name: Compile examples
+        uses: arduino/compile-sketches@v1
+        with:
+          fqbn: ${{ matrix.board.fqbn }}
+          platforms: ${{ matrix.board.platforms }}
+          libraries: |
+            # Install the library from the local path.
+            - source-path: ./
+          sketch-paths: |
+            - examples/arduino_renesas/arduino_uno_r4_wifi
+          enable-deltas-report: true
+          sketches-report-path: ${{ env.SKETCHES_REPORTS_PATH }}
+
+      - name: Save sketches report as workflow artifact
+        uses: actions/upload-artifact@v4
+        with:
+          if-no-files-found: error
+          path: ${{ env.SKETCHES_REPORTS_PATH }}
+          name: sketches-report-${{ matrix.board.artifact-name-suffix }}

.github/workflows/main.yml

@@ -0,0 +1,171 @@
+name: CI
+on:
+  schedule:
+    - cron: '0 0 * * 5'
+  push:
+    branches: [ master ]
+  pull_request:
+    branches: [ master ]
+  release:
+    types: [ published, created, edited ]
+
+  # Allows you to run this workflow manually from the Actions tab
+  workflow_dispatch:
+
+# A workflow run is made up of one or more jobs that can run sequentially or in parallel
+jobs:
+  check_version_files:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: check version
+        run: |
+          $GITHUB_WORKSPACE/travis/version.py --check
+
+  prepare_example_json:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: generate examples
+        id: set-matrix
+        run: |
+          source $GITHUB_WORKSPACE/travis/common.sh
+          cd $GITHUB_WORKSPACE
+
+          echo -en "matrix=" >> $GITHUB_OUTPUT
+          echo -en "[" >> $GITHUB_OUTPUT
+
+          get_sketches_json_matrix arduino $GITHUB_WORKSPACE/examples/esp8266_pico esp8266 0.35.3 esp8266:esp8266:generic:xtal=80,vt=flash,exception=disabled,stacksmash=disabled,ssl=all,mmu=3232,non32xfer=fast,ResetMethod=nodemcu,CrystalFreq=26,FlashFreq=80,FlashMode=qio,eesz=4M2M,led=2,sdk=nonosdk_190703,ip=lm2f,dbg=Serial1,lvl=SSL,wipe=none,baud=115200 >> $GITHUB_OUTPUT
+          echo -en "," >> $GITHUB_OUTPUT
+
+          get_sketches_json_matrix arduino $GITHUB_WORKSPACE/examples/esp8266_pico esp8266 0.35.3 esp8266:esp8266:generic:xtal=80,vt=flash,exception=disabled,stacksmash=disabled,ssl=all,mmu=3232,non32xfer=fast,ResetMethod=nodemcu,CrystalFreq=26,FlashFreq=80,FlashMode=qio,eesz=4M2M,led=2,sdk=nonosdk_190703,ip=lm2f,dbg=Disabled,lvl=None____,wipe=none,baud=115200 >> $GITHUB_OUTPUT
+          echo -en "," >> $GITHUB_OUTPUT
+
+          get_sketches_json_matrix arduino $GITHUB_WORKSPACE/examples/esp32 esp32 0.35.3 esp32:esp32:esp32:FlashFreq=80 >> $GITHUB_OUTPUT
+
+          echo -en "]" >> $GITHUB_OUTPUT
+          echo >> $GITHUB_OUTPUT
+    outputs:
+      matrix: ${{ steps.set-matrix.outputs.matrix }}
+
+  prepare_ide:
+    runs-on: ubuntu-latest
+    strategy:
+      fail-fast: false
+      matrix:
+        CLI_VERSION: [0.35.3]
+    env:
+      CLI_VERSION: ${{ matrix.CLI_VERSION }}
+      ARDUINO_DIRECTORIES_DATA: /home/runner/arduino_ide
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Get hash
+        id: get-hash
+        run: |
+          echo "hash=$(/bin/date -u "+%Y%m%d")-$(md5sum ".github/workflows/main.yml" | cut -d ' ' -f 1)" >> $GITHUB_OUTPUT
+        shell: bash
+
+      - uses: actions/cache@v4
+        id: cache_all
+        with:
+          path: |
+            /home/runner/arduino_ide
+            /home/runner/Arduino
+          key: ${{ runner.os }}-${{ steps.get-hash.outputs.hash }}-${{ matrix.CLI_VERSION }}-cli
+
+      - name: download IDE
+        if: steps.cache_all.outputs.cache-hit != 'true'
+        run: |
+          wget https://github.com/arduino/arduino-cli/releases/download/v${CLI_VERSION}/arduino-cli_${CLI_VERSION}_Linux_64bit.tar.gz -q
+          tar xf arduino-cli_${CLI_VERSION}_Linux_64bit.tar.gz
+          mkdir -p $ARDUINO_DIRECTORIES_DATA
+          mv arduino-cli $ARDUINO_DIRECTORIES_DATA/
+
+      - name: download ArduinoJson
+        if: steps.cache_all.outputs.cache-hit != 'true'
+        run: |
+          mkdir -p $HOME/Arduino/libraries
+          wget https://github.com/bblanchon/ArduinoJson/archive/6.x.zip -q
+          unzip 6.x.zip
+          mv ArduinoJson-6.x $HOME/Arduino/libraries/ArduinoJson
+
+      - name: download cores
+        if: steps.cache_all.outputs.cache-hit != 'true'
+        run: |
+          export PATH="$ARDUINO_DIRECTORIES_DATA:$PATH"
+          source $GITHUB_WORKSPACE/travis/common.sh
+          get_core_cli
+
+  build:
+    needs: [prepare_ide, prepare_example_json]
+    runs-on: ubuntu-latest
+    strategy:
+      fail-fast: false
+      matrix:
+        include: ${{ fromJson(needs.prepare_example_json.outputs.matrix) }}
+    env:
+      CPU: ${{ matrix.cpu }}
+      BOARD: ${{ matrix.board }}
+      CLI_VERSION: ${{ matrix.cliversion }}
+      SKETCH: ${{ matrix.sketch }}
+      ARDUINO_DIRECTORIES_DATA: /home/runner/arduino_ide
+
+    # Steps represent a sequence of tasks that will be executed as part of the job
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: install libgtk2.0-0
+        run: |
+          sudo apt-get install -y libgtk2.0-0
+
+      - name: Get hash
+        id: get-hash
+        run: |
+          echo "hash=$(/bin/date -u "+%Y%m%d")-$(md5sum ".github/workflows/main.yml" | cut -d ' ' -f 1)" >> $GITHUB_OUTPUT
+        shell: bash
+
+      - uses: actions/cache@v4
+        id: cache_all
+        with:
+          path: |
+            /home/runner/arduino_ide
+            /home/runner/Arduino
+          key: ${{ runner.os }}-${{ steps.get-hash.outputs.hash }}-${{ matrix.cliversion }}-cli
+
+      - name: install python serial
+        if: matrix.cpu == 'esp32'
+        run: |
+          sudo pip3 install pyserial
+          sudo pip install pyserial
+#          sudo apt install python-is-python3
+
+      - name: test IDE
+        run: |
+          export PATH="$ARDUINO_DIRECTORIES_DATA:$PATH"
+          which arduino-cli
+
+      - name: copy code
+        run: |
+          mkdir -p $HOME/Arduino/libraries/
+          cp -r $GITHUB_WORKSPACE $HOME/Arduino/libraries/arduinoWebSockets
+
+      - name: build example
+        timeout-minutes: 20
+        run: |
+          set -ex
+          export PATH="$HOME/arduino_ide:$PATH"
+          source $GITHUB_WORKSPACE/travis/common.sh
+          cd $GITHUB_WORKSPACE
+          build_sketch_cli "$SKETCH" "$BOARD"
+
+  done:
+    needs: [prepare_ide, prepare_example_json, build, check_version_files]
+    runs-on: ubuntu-latest
+    steps:
+      - name: Done
+        run: |
+          echo DONE

.gitignore

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

.travis.yml

@@ -0,0 +1,45 @@
+sudo: false
+dist:
+  - xenial
+addons:
+  apt:
+    packages:
+      - xvfb
+language: bash
+os:
+  - linux
+env:
+  matrix:
+    - CPU="esp8266" BOARD="esp8266com:esp8266:generic:xtal=80" IDE_VERSION=1.6.13
+    - CPU="esp8266" BOARD="esp8266com:esp8266:generic:xtal=80,dbg=Serial1" IDE_VERSION=1.6.13
+    - CPU="esp8266" BOARD="esp8266com:esp8266:generic:xtal=80,eesz=1M,FlashMode=qio,FlashFreq=80" IDE_VERSION=1.8.13
+    - 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.13
+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
+  - 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:
+  email:
+    on_success: change
+    on_failure: change

README.md

@@ -1,30 +1,110 @@
-WebSocket Server and Client for Arduino
+WebSocket Server and Client for Arduino [![Build Status](https://github.com/Links2004/arduinoWebSockets/actions/workflows/main.yml/badge.svg?branch=master)](https://github.com/Links2004/arduinoWebSockets/actions?query=branch%3Amaster)
 ===========================================
 
 a WebSocket Server and Client for Arduino based on RFC6455.
 
+
 ##### Supported features of RFC6455 #####
  - text frame
  - binary frame
  - connection close
  - ping
  - pong
- 
-##### Not supported features of RFC6455 #####
  - continuation frame
-  
+
 ##### Limitations #####
  - max input length is limited to the ram size and the ```WEBSOCKETS_MAX_DATA_SIZE``` define
  - max output length has no limit (the hardware is the limit)
- - Client send masked frames always with mask 0x00000000 (open todo)
+ - Client send big frames with mask 0x00000000 (on AVR all frames)
+ - continuation frame reassembly need to be handled in the application code
+
+ ##### Limitations for Async #####
+ - Functions called from within the context of the websocket event might not honor `yield()` and/or `delay()`.  See [this issue](https://github.com/Links2004/arduinoWebSockets/issues/58#issuecomment-192376395) for more info and a potential workaround.
+ - wss / SSL is not possible.
 
 ##### Supported Hardware #####
- - ESP8266 [Arduino for ESP8266](https://github.com/Links2004/Arduino)
- - ATmega328 with Ethernet Shield (planed)
- - ATmega328 with enc28j60 (planed)
- - ATmega2560 with Ethernet Shield (planed)
- - ATmega2560 with enc28j60 (planed)
- 
+ - ESP8266 [Arduino for ESP8266](https://github.com/esp8266/Arduino/)
+ - ESP32 [Arduino for ESP32](https://github.com/espressif/arduino-esp32)
+ - ESP31B
+ - Raspberry Pi Pico W [Arduino for Pico](https://github.com/earlephilhower/arduino-pico)
+ - Particle with STM32 ARM Cortex M3
+ - ATmega328 with Ethernet Shield (ATmega branch)
+ - ATmega328 with enc28j60 (ATmega branch)
+ - ATmega2560 with Ethernet Shield (ATmega branch)
+ - ATmega2560 with enc28j60 (ATmega branch)
+ - Arduino UNO [R4 WiFi](https://github.com/arduino/ArduinoCore-renesas)
+ - Arduino Nano 33 IoT, MKR WIFI 1010 (requires [WiFiNINA](https://github.com/arduino-libraries/WiFiNINA/) library)
+ - Seeeduino XIAO, Seeeduino Wio Terminal (requires [rpcWiFi](https://github.com/Seeed-Studio/Seeed_Arduino_rpcWiFi) library)
+
+###### Note: ######
+
+  version 2.0.0 and up is not compatible with AVR/ATmega, check ATmega branch.
+
+  version 2.3.0 has API changes for the ESP8266 BareSSL (may brakes existing code)
+
+  Arduino for AVR not supports std namespace of c++.
+
+### wss / SSL ###
+ supported for:
+ - wss client on the ESP8266
+ - wss / SSL for ESP32 in client mode
+ - wss / SSL is not natively supported in WebSocketsServer however it is possible to achieve secure websockets
+   by running the device behind an SSL proxy. See [Nginx](examples/Nginx/esp8266.ssl.reverse.proxy.conf) for a
+   sample Nginx server configuration file to enable this.
+
+### Root CA Cert Bundles for SSL/TLS connections ###
+
+Secure connections require the certificate of the server to be verified. One option is to provide a single certificate in the chain of trust. However, for flexibility and robustness, a certificate bundle is recommended. If a server changes the root CA from which it derives its certificates, this will not be a problem. With a single CA cert it will not connect.
+
+ - For [technical details](https://docs.espressif.com/projects/esp-idf/en/latest/esp32/api-reference/protocols/esp_crt_bundle.html)
+ - For a [PlatformIO setup](https://github.com/Duckle29/esp32-certBundle/)
+ - For an [example](examples/esp32/WebSocketClientSSLBundle/)
+
+Including a bundle with all CA certs will use 77.2 kB but this list can be reduced to 16.5 kB for the 41 most common. This results in 90% absolute usage coverage and 99% market share coverage according to [W3Techs](https://w3techs.com/technologies/overview/ssl_certificate). The bundle is inserted into the compiled firmware. The bundle is not loaded into RAM, only its index.
+
+### ESP Async TCP ###
+
+This libary can run in Async TCP mode on the ESP.
+
+The mode can be activated in the ```WebSockets.h``` (see WEBSOCKETS_NETWORK_TYPE define).
+
+[ESPAsyncTCP](https://github.com/me-no-dev/ESPAsyncTCP) libary is required.
+
+
+### 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,
+      WStype_CONNECTED,
+      WStype_TEXT,
+      WStype_BIN,
+      WStype_FRAGMENT_TEXT_START,
+      WStype_FRAGMENT_BIN_START,
+      WStype_FRAGMENT,
+      WStype_FRAGMENT_FIN,
+      WStype_PING,
+      WStype_PONG,
+  } WStype_t;
+```
+
 ### Issues ###
 Submit issues to: https://github.com/Links2004/arduinoWebSockets/issues
 

examples/Nginx/esp8266.ssl.reverse.proxy.conf

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

examples/arduino_renesas/arduino_uno_r4_wifi/arduino_uno_r4_wifi.ino

@@ -0,0 +1,109 @@
+#include <Arduino.h>
+#include <stdarg.h>
+#include <stdio.h>
+
+#include "WiFiS3.h"
+#include <WebSocketsClient.h>
+
+#define WIFI_SSID ""
+#define WIFI_PASS ""
+
+WebSocketsClient webSocket;
+ 
+void webSocketEvent(WStype_t type, uint8_t *payload, size_t length) {
+
+  switch (type) {
+    case WStype_DISCONNECTED:
+      Serial.println("[WSc] Disconnected!");
+      break;
+    case WStype_CONNECTED:
+      Serial.println("[WSc] Connected!");
+
+      // send message to server when Connected
+      webSocket.sendTXT("Connected");
+      break;
+    case WStype_TEXT:
+      Serial.print("[WSc] get text:");
+      Serial.println((char *)payload);
+
+      // send message to server
+      // webSocket.sendTXT("message here");
+      break;
+    case WStype_BIN:
+      // send data to server
+      // webSocket.sendBIN(payload, length);
+      break;
+    case WStype_ERROR:
+    case WStype_FRAGMENT_TEXT_START:
+    case WStype_FRAGMENT_BIN_START:
+    case WStype_FRAGMENT:
+    case WStype_FRAGMENT_FIN:
+      break;
+  }
+}
+
+void setup() {
+  Serial.begin(115200);
+
+  while (!Serial) {
+    ;  // wait for serial port to connect. Needed for native USB port only
+  }
+
+  Serial.println();
+  Serial.println();
+  Serial.println();
+
+  for (uint8_t t = 4; t > 0; t--) {
+    Serial.println("[SETUP] BOOT WAIT ...");
+    Serial.flush();
+    delay(1000);
+  }
+
+  // check for the WiFi module:
+  if (WiFi.status() == WL_NO_MODULE) {
+    Serial.println("Communication with WiFi module failed!");
+    // don't continue
+    while (true)
+      ;
+  }
+
+  String fv = WiFi.firmwareVersion();
+  if (fv < WIFI_FIRMWARE_LATEST_VERSION) {
+    Serial.println("Please upgrade the firmware");
+  }
+
+  Serial.println("[Wifi]: Connecting");
+
+  int status = WL_IDLE_STATUS;
+
+  // attempt to connect to WiFi network:
+  while (status != WL_CONNECTED) {
+    Serial.print("[Wifi]: Attempting to connect to SSID: ");
+    Serial.println(WIFI_SSID);
+
+    // Connect to WPA/WPA2 network. Change this line if using open or WEP network:
+    status = WiFi.begin(WIFI_SSID, WIFI_PASS);
+
+    delay(1000);
+  }
+
+  Serial.println("Connected!");
+
+  // print your board's IP address:
+  IPAddress ip = WiFi.localIP();
+  Serial.print("IP Address: ");
+  Serial.println(ip);
+
+  // server address, port and URL
+  webSocket.begin("192.168.0.123", 8011);
+
+  // event handler
+  webSocket.onEvent(webSocketEvent);
+
+  // try ever 5000 again if connection has failed
+  webSocket.setReconnectInterval(5000);
+}
+
+void loop() {
+  webSocket.loop();
+}

examples/arduino_wifinina/arduino_wifinina.ino

@@ -0,0 +1,100 @@
+#include <Arduino.h>
+#include <SPI.h>
+#include <WiFiNINA.h>
+#include <WebSocketsClient.h>
+
+#define WIFI_SSID ""
+#define WIFI_PASS ""
+
+int status = WL_IDLE_STATUS;
+WiFiClient client;
+WebSocketsClient webSocket;
+
+void webSocketEvent(WStype_t type, uint8_t *payload, size_t length) {
+
+  switch (type) {
+    case WStype_DISCONNECTED:
+      Serial.println("[WSc] Disconnected!");
+      break;
+    case WStype_CONNECTED:
+      Serial.println("[WSc] Connected!");
+
+      // send message to server when Connected
+      webSocket.sendTXT("Connected");
+      break;
+    case WStype_TEXT:
+      Serial.print("[WSc] get text:");
+      Serial.println((char *)payload);
+
+      // send message to server
+      // webSocket.sendTXT("message here");
+      break;
+    case WStype_BIN:
+      // send data to server
+      // webSocket.sendBIN(payload, length);
+      break;
+    case WStype_ERROR:
+    case WStype_FRAGMENT_TEXT_START:
+    case WStype_FRAGMENT_BIN_START:
+    case WStype_FRAGMENT:
+    case WStype_PING:
+    case WStype_PONG:
+    case WStype_FRAGMENT_FIN:
+      break;
+  }
+}
+
+void setup() {
+  Serial.begin(115200);
+
+  while (!Serial) {
+    ;  // wait for serial port to connect. Needed for native USB port only
+  }
+
+  Serial.println();
+  Serial.println();
+  Serial.println();
+
+  // check for the WiFi module:
+  if (WiFi.status() == WL_NO_MODULE) {
+    Serial.println("Communication with WiFi module failed!");
+    // don't continue
+    while (true);
+  }
+
+  String fv = WiFi.firmwareVersion();
+  if (fv < WIFI_FIRMWARE_LATEST_VERSION) {
+    Serial.println("Please upgrade the firmware");
+  }
+
+  // attempt to connect to WiFi network:
+  while (status != WL_CONNECTED) {
+    Serial.print("Attempting to connect to SSID: ");
+    Serial.println(WIFI_SSID);
+    // Connect to WPA/WPA2 network. Change this line if using open or WEP network:
+    status = WiFi.begin(WIFI_SSID, WIFI_PASS);
+
+    // wait 10 seconds for connection:
+    delay(10000);
+  }
+
+  Serial.println("Connected to WiFi");
+
+  // print your board's IP address:
+  IPAddress ip = WiFi.localIP();
+  Serial.print("IP Address: ");
+  Serial.println(ip);
+
+  // server address, port and URL
+  webSocket.begin("192.168.0.123", 8011);
+
+  // event handler
+  webSocket.onEvent(webSocketEvent);
+
+  // try ever 5000 again if connection has failed
+  webSocket.setReconnectInterval(5000);
+}
+
+void loop() {
+  webSocket.loop();
+}

examples/avr/WebSocketClientAVR/WebSocketClientAVR.ino

@@ -0,0 +1,84 @@
+/*
+ * WebSocketClientAVR.ino
+ *
+ *  Created on: 10.12.2015
+ *
+ */
+
+#include <Arduino.h>
+
+#include <SPI.h>
+#include <Ethernet.h>
+
+#include <WebSocketsClient.h>
+
+
+
+// Enter a MAC address for your controller below.
+// Newer Ethernet shields have a MAC address printed on a sticker on the shield
+byte mac[] = { 0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED };
+
+// Set the static IP address to use if the DHCP fails to assign
+IPAddress ip(192, 168, 0, 177);
+
+WebSocketsClient webSocket;
+
+
+
+void webSocketEvent(WStype_t type, uint8_t * payload, size_t length) {
+
+
+    switch(type) {
+        case WStype_DISCONNECTED:
+            Serial.println("[WSc] Disconnected!\n");
+            break;
+        case WStype_CONNECTED:
+            {
+                Serial.print("[WSc] Connected to url: ");
+                Serial.println((char *)payload);
+                // send message to server when Connected
+                webSocket.sendTXT("Connected");
+            }
+            break;
+        case WStype_TEXT:
+            Serial.print("[WSc] get text: ");
+            Serial.println((char *)payload);
+            // send message to server
+            // webSocket.sendTXT("message here");
+            break;
+        case WStype_BIN:
+            Serial.print("[WSc] get binary length: ");
+            Serial.println(length);
+           // hexdump(payload, length);
+
+            // send data to server
+            // webSocket.sendBIN(payload, length);
+            break;
+    }
+
+}
+
+void setup()
+{
+    // Open serial communications and wait for port to open:
+    Serial.begin(115200);
+    while (!Serial) {}
+
+    // start the Ethernet connection:
+    if (Ethernet.begin(mac) == 0) {
+      Serial.println("Failed to configure Ethernet using DHCP");
+      // no point in carrying on, so do nothing forevermore:
+      // try to congifure using IP address instead of DHCP:
+      Ethernet.begin(mac, ip);
+    }
+
+    webSocket.begin("192.168.0.123", 8011);
+    webSocket.onEvent(webSocketEvent);
+
+}
+
+
+void loop()
+{
+    webSocket.loop();
+}

examples/esp32/WebSocketClient/WebSocketClient.ino

@@ -0,0 +1,110 @@
+/*
+ * WebSocketClient.ino
+ *
+ *  Created on: 24.05.2015
+ *
+ */
+
+#include <Arduino.h>
+
+#include <WiFi.h>
+#include <WiFiMulti.h>
+#include <WiFiClientSecure.h>
+
+#include <WebSocketsClient.h>
+
+
+WiFiMulti WiFiMulti;
+WebSocketsClient webSocket;
+
+#define USE_SERIAL Serial1
+
+void hexdump(const void *mem, uint32_t len, uint8_t cols = 16) {
+	const uint8_t* src = (const uint8_t*) mem;
+	USE_SERIAL.printf("\n[HEXDUMP] Address: 0x%08X len: 0x%X (%d)", (ptrdiff_t)src, len, len);
+	for(uint32_t i = 0; i < len; i++) {
+		if(i % cols == 0) {
+			USE_SERIAL.printf("\n[0x%08X] 0x%08X: ", (ptrdiff_t)src, i);
+		}
+		USE_SERIAL.printf("%02X ", *src);
+		src++;
+	}
+	USE_SERIAL.printf("\n");
+}
+
+void webSocketEvent(WStype_t type, uint8_t * payload, size_t length) {
+
+	switch(type) {
+		case WStype_DISCONNECTED:
+			USE_SERIAL.printf("[WSc] Disconnected!\n");
+			break;
+		case WStype_CONNECTED:
+			USE_SERIAL.printf("[WSc] Connected to url: %s\n", payload);
+
+			// send message to server when Connected
+			webSocket.sendTXT("Connected");
+			break;
+		case WStype_TEXT:
+			USE_SERIAL.printf("[WSc] get text: %s\n", payload);
+
+			// send message to server
+			// webSocket.sendTXT("message here");
+			break;
+		case WStype_BIN:
+			USE_SERIAL.printf("[WSc] get binary length: %u\n", length);
+			hexdump(payload, length);
+
+			// send data to server
+			// webSocket.sendBIN(payload, length);
+			break;
+		case WStype_ERROR:			
+		case WStype_FRAGMENT_TEXT_START:
+		case WStype_FRAGMENT_BIN_START:
+		case WStype_FRAGMENT:
+		case WStype_FRAGMENT_FIN:
+			break;
+	}
+
+}
+
+void setup() {
+	// USE_SERIAL.begin(921600);
+	USE_SERIAL.begin(115200);
+
+	//Serial.setDebugOutput(true);
+	USE_SERIAL.setDebugOutput(true);
+
+	USE_SERIAL.println();
+	USE_SERIAL.println();
+	USE_SERIAL.println();
+
+	for(uint8_t t = 4; t > 0; t--) {
+		USE_SERIAL.printf("[SETUP] BOOT WAIT %d...\n", t);
+		USE_SERIAL.flush();
+		delay(1000);
+	}
+
+	WiFiMulti.addAP("SSID", "passpasspass");
+
+	//WiFi.disconnect();
+	while(WiFiMulti.run() != WL_CONNECTED) {
+		delay(100);
+	}
+
+	// server address, port and URL
+	webSocket.begin("192.168.0.123", 81, "/");
+
+	// event handler
+	webSocket.onEvent(webSocketEvent);
+
+	// use HTTP Basic Authorization this is optional remove if not needed
+	webSocket.setAuthorization("user", "Password");
+
+	// try ever 5000 again if connection has failed
+	webSocket.setReconnectInterval(5000);
+
+}
+
+void loop() {
+	webSocket.loop();
+}

examples/esp32/WebSocketClientSSL/WebSocketClientSSL.ino

@@ -0,0 +1,106 @@
+/*
+ * WebSocketClientSSL.ino
+ *
+ *  Created on: 10.12.2015
+ *
+ *  note SSL is only possible with the ESP8266
+ *
+ */
+
+#include <Arduino.h>
+
+#include <WiFi.h>
+#include <WiFiMulti.h>
+#include <WiFiClientSecure.h>
+
+#include <WebSocketsClient.h>
+
+
+WiFiMulti WiFiMulti;
+WebSocketsClient webSocket;
+
+#define USE_SERIAL Serial1
+
+void hexdump(const void *mem, uint32_t len, uint8_t cols = 16) {
+	const uint8_t* src = (const uint8_t*) mem;
+	USE_SERIAL.printf("\n[HEXDUMP] Address: 0x%08X len: 0x%X (%d)", (ptrdiff_t)src, len, len);
+	for(uint32_t i = 0; i < len; i++) {
+		if(i % cols == 0) {
+			USE_SERIAL.printf("\n[0x%08X] 0x%08X: ", (ptrdiff_t)src, i);
+		}
+		USE_SERIAL.printf("%02X ", *src);
+		src++;
+	}
+	USE_SERIAL.printf("\n");
+}
+
+void webSocketEvent(WStype_t type, uint8_t * payload, size_t length) {
+
+
+    switch(type) {
+        case WStype_DISCONNECTED:
+            USE_SERIAL.printf("[WSc] Disconnected!\n");
+            break;
+        case WStype_CONNECTED:
+            {
+                USE_SERIAL.printf("[WSc] Connected to url: %s\n",  payload);
+
+			    // send message to server when Connected
+				webSocket.sendTXT("Connected");
+            }
+            break;
+        case WStype_TEXT:
+            USE_SERIAL.printf("[WSc] get text: %s\n", payload);
+
+			// send message to server
+			// webSocket.sendTXT("message here");
+            break;
+        case WStype_BIN:
+            USE_SERIAL.printf("[WSc] get binary length: %u\n", length);
+            hexdump(payload, length);
+
+            // send data to server
+            // webSocket.sendBIN(payload, length);
+            break;
+		case WStype_ERROR:			
+		case WStype_FRAGMENT_TEXT_START:
+		case WStype_FRAGMENT_BIN_START:
+		case WStype_FRAGMENT:
+		case WStype_FRAGMENT_FIN:
+			break;
+    }
+
+}
+
+void setup() {
+    // USE_SERIAL.begin(921600);
+    USE_SERIAL.begin(115200);
+
+    //Serial.setDebugOutput(true);
+    USE_SERIAL.setDebugOutput(true);
+
+    USE_SERIAL.println();
+    USE_SERIAL.println();
+    USE_SERIAL.println();
+
+      for(uint8_t t = 4; t > 0; t--) {
+          USE_SERIAL.printf("[SETUP] BOOT WAIT %d...\n", t);
+          USE_SERIAL.flush();
+          delay(1000);
+      }
+
+    WiFiMulti.addAP("SSID", "passpasspass");
+
+    //WiFi.disconnect();
+    while(WiFiMulti.run() != WL_CONNECTED) {
+        delay(100);
+    }
+
+    webSocket.beginSSL("192.168.0.123", 81);
+    webSocket.onEvent(webSocketEvent);
+
+}
+
+void loop() {
+    webSocket.loop();
+}

examples/esp32/WebSocketClientSSLBundle/WebSocketClientSSLBundle.ino

@@ -0,0 +1,135 @@
+/*
+ * main.cpp
+ *
+ *  Created on: 15.06.2024
+ *
+ */
+
+#include <Arduino.h>
+#include <WiFi.h>
+#include <WiFiMulti.h>
+
+#include <WebSocketsClient.h>
+
+// Use the incbin library to embedd the cert binary
+// extern const uint8_t rootca_crt_bundle_start[] asm(
+//     "_binary_data_cert_x509_crt_bundle_bin_start");
+
+WiFiMulti wifiMulti;
+WebSocketsClient webSocket;
+
+#define USE_SERIAL Serial
+
+void setClock() {
+    configTime(0, 0, "pool.ntp.org", "time.nist.gov");
+
+    USE_SERIAL.print(F("Waiting for NTP time sync: "));
+    time_t nowSecs = time(nullptr);
+    while(nowSecs < 8 * 3600 * 2) {
+        delay(500);
+        USE_SERIAL.print(F("."));
+        yield();
+        nowSecs = time(nullptr);
+    }
+
+    USE_SERIAL.println();
+    struct tm timeinfo;
+    gmtime_r(&nowSecs, &timeinfo);
+    USE_SERIAL.print(F("Current time: "));
+    USE_SERIAL.print(asctime(&timeinfo));
+}
+
+void hexdump(const void * mem, uint32_t len, uint8_t cols = 16) {
+    const uint8_t * src = (const uint8_t *)mem;
+    USE_SERIAL.printf("\n[HEXDUMP] Address: 0x%08X len: 0x%X (%d)", (ptrdiff_t)src, len, len);
+    for(uint32_t i = 0; i < len; i++) {
+        if(i % cols == 0) {
+            USE_SERIAL.printf("\n[0x%08X] 0x%08X: ", (ptrdiff_t)src, i);
+        }
+        USE_SERIAL.printf("%02X ", *src);
+        src++;
+    }
+    USE_SERIAL.printf("\n");
+}
+
+void webSocketEvent(WStype_t type, uint8_t * payload, size_t length) {
+    switch(type) {
+        case WStype_DISCONNECTED:
+            USE_SERIAL.printf("[WSc] Disconnected!\n");
+            break;
+        case WStype_CONNECTED:
+            USE_SERIAL.printf("[WSc] Connected to url: %s\n", payload);
+
+            // send message to server when Connected
+            webSocket.sendTXT("Connected");
+            break;
+        case WStype_TEXT:
+            USE_SERIAL.printf("[WSc] get text: %s\n", payload);
+
+            // send message to server
+            // webSocket.sendTXT("message here");
+            break;
+        case WStype_BIN:
+            USE_SERIAL.printf("[WSc] get binary length: %u\n", length);
+            hexdump(payload, length);
+
+            // send data to server
+            // webSocket.sendBIN(payload, length);
+            break;
+        case WStype_ERROR:
+        case WStype_FRAGMENT_TEXT_START:
+        case WStype_FRAGMENT_BIN_START:
+        case WStype_FRAGMENT:
+        case WStype_FRAGMENT_FIN:
+            break;
+    }
+}
+
+void setup() {
+    USE_SERIAL.begin(115200);
+
+    USE_SERIAL.setDebugOutput(true);
+
+    USE_SERIAL.println();
+    USE_SERIAL.println();
+    USE_SERIAL.println();
+
+    for(uint8_t t = 4; t > 0; t--) {
+        USE_SERIAL.printf("[SETUP] BOOT WAIT %d...\n", t);
+        USE_SERIAL.flush();
+        delay(1000);
+    }
+
+    wifiMulti.addAP("SSID", "WIFI_PASSPHRASE");
+
+    // WiFi.disconnect();
+    while(wifiMulti.run() != WL_CONNECTED) {
+        delay(100);
+    }
+
+    setClock();
+
+    // server address, port and URL. This server can be flakey.
+    // Expected response: Request served by 0123456789abcdef
+    // webSocket.beginSslWithBundle("echo.websocket.org", 443, "/", rootca_crt_bundle_start, "");
+    // ESP32 3.0.4 or higher needs the size of the bundle
+    // webSocket.beginSslWithBundle("echo.websocket.org", 443, "/", rootca_crt_bundle_start, sizeof(rootca_crt_bundle_start), "");
+#if ESP_ARDUINO_VERSION >= ESP_ARDUINO_VERSION_VAL(3, 0, 4)
+    webSocket.beginSslWithBundle("echo.websocket.org", 443, "/", NULL, 0, "");
+#else
+    webSocket.beginSslWithBundle("echo.websocket.org", 443, "/", NULL, "");
+#endif
+
+    // event handler
+    webSocket.onEvent(webSocketEvent);
+
+    // use HTTP Basic Authorization this is optional enable if needed
+    // webSocket.setAuthorization("user", "Password");
+
+    // try ever 5000 again if connection has failed
+    webSocket.setReconnectInterval(5000);
+}
+
+void loop() {
+    webSocket.loop();
+}

examples/esp32/WebSocketClientSocketIOack/WebSocketClientSocketIOack.ino

@@ -0,0 +1,155 @@
+/*
+ * WebSocketClientSocketIOack.ino
+ *
+ *  Created on: 20.07.2019
+ *
+ */
+
+#include <Arduino.h>
+
+#include <WiFi.h>
+#include <WiFiMulti.h>
+#include <WiFiClientSecure.h>
+
+#include <ArduinoJson.h>
+
+#include <WebSocketsClient.h>
+#include <SocketIOclient.h>
+
+WiFiMulti 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);
+
+            // join default namespace (no auto join in Socket.IO V3)
+            socketIO.send(sIOtype_CONNECT, "/");
+            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) {
+                // create 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);
+            break;
+        case sIOtype_ERROR:
+            USE_SERIAL.printf("[IOc] get error: %u\n", length);
+            break;
+        case sIOtype_BINARY_EVENT:
+            USE_SERIAL.printf("[IOc] get binary: %u\n", length);
+            break;
+        case sIOtype_BINARY_ACK:
+            USE_SERIAL.printf("[IOc] get binary ack: %u\n", 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);
+      }
+
+    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, "/socket.io/?EIO=4");
+
+    // event handler
+    socketIO.onEvent(socketIOEvent);
+}
+
+unsigned long messageTimestamp = 0;
+void loop() {
+    socketIO.loop();
+
+    uint64_t now = millis();
+
+    if(now - messageTimestamp > 2000) {
+        messageTimestamp = now;
+
+        // create JSON message for Socket.IO (event)
+        DynamicJsonDocument doc(1024);
+        JsonArray array = doc.to<JsonArray>();
+
+        // add event name
+        // Hint: socket.on('event_name', ....
+        array.add("event_name");
+
+        // add payload (parameters) for the event
+        JsonObject param1 = array.createNestedObject();
+        param1["now"] = (uint32_t) now;
+
+        // JSON to String (serialization)
+        String output;
+        serializeJson(doc, output);
+
+        // Send event
+        socketIO.sendEVENT(output);
+
+        // Print JSON for debugging
+        USE_SERIAL.println(output);
+    }
+}

examples/esp32/WebSocketServer/WebSocketServer.ino

@@ -0,0 +1,104 @@
+/*
+ * WebSocketServer.ino
+ *
+ *  Created on: 22.05.2015
+ *
+ */
+
+#include <Arduino.h>
+
+#include <WiFi.h>
+#include <WiFiMulti.h>
+#include <WiFiClientSecure.h>
+
+#include <WebSocketsServer.h>
+
+WiFiMulti WiFiMulti;
+WebSocketsServer webSocket = WebSocketsServer(81);
+
+#define USE_SERIAL Serial1
+
+void hexdump(const void *mem, uint32_t len, uint8_t cols = 16) {
+	const uint8_t* src = (const uint8_t*) mem;
+	USE_SERIAL.printf("\n[HEXDUMP] Address: 0x%08X len: 0x%X (%d)", (ptrdiff_t)src, len, len);
+	for(uint32_t i = 0; i < len; i++) {
+		if(i % cols == 0) {
+			USE_SERIAL.printf("\n[0x%08X] 0x%08X: ", (ptrdiff_t)src, i);
+		}
+		USE_SERIAL.printf("%02X ", *src);
+		src++;
+	}
+	USE_SERIAL.printf("\n");
+}
+
+void webSocketEvent(uint8_t num, WStype_t type, uint8_t * payload, size_t length) {
+
+    switch(type) {
+        case WStype_DISCONNECTED:
+            USE_SERIAL.printf("[%u] Disconnected!\n", num);
+            break;
+        case WStype_CONNECTED:
+            {
+                IPAddress ip = webSocket.remoteIP(num);
+                USE_SERIAL.printf("[%u] Connected from %d.%d.%d.%d url: %s\n", num, ip[0], ip[1], ip[2], ip[3], payload);
+
+		// send message to client
+		webSocket.sendTXT(num, "Connected");
+            }
+            break;
+        case WStype_TEXT:
+            USE_SERIAL.printf("[%u] get Text: %s\n", num, payload);
+
+            // send message to client
+            // webSocket.sendTXT(num, "message here");
+
+            // send data to all connected clients
+            // webSocket.broadcastTXT("message here");
+            break;
+        case WStype_BIN:
+            USE_SERIAL.printf("[%u] get binary length: %u\n", num, length);
+            hexdump(payload, length);
+
+            // send message to client
+            // webSocket.sendBIN(num, payload, length);
+            break;
+	case WStype_ERROR:			
+	case WStype_FRAGMENT_TEXT_START:
+	case WStype_FRAGMENT_BIN_START:
+	case WStype_FRAGMENT:
+	case WStype_FRAGMENT_FIN:
+	    break;
+    }
+
+}
+
+void setup() {
+    // USE_SERIAL.begin(921600);
+    USE_SERIAL.begin(115200);
+
+    //Serial.setDebugOutput(true);
+    USE_SERIAL.setDebugOutput(true);
+
+    USE_SERIAL.println();
+    USE_SERIAL.println();
+    USE_SERIAL.println();
+
+    for(uint8_t t = 4; t > 0; t--) {
+        USE_SERIAL.printf("[SETUP] BOOT WAIT %d...\n", t);
+        USE_SERIAL.flush();
+        delay(1000);
+    }
+
+    WiFiMulti.addAP("SSID", "passpasspass");
+
+    while(WiFiMulti.run() != WL_CONNECTED) {
+        delay(100);
+    }
+
+    webSocket.begin();
+    webSocket.onEvent(webSocketEvent);
+}
+
+void loop() {
+    webSocket.loop();
+}

examples/esp32_pio/WebSocketClientSSLBundle/.gitignore

@@ -0,0 +1,8 @@
+.pio
+.vscode/.browse.c_cpp.db*
+.vscode/c_cpp_properties.json
+.vscode/launch.json
+.vscode/ipch
+*secret*
+!*secrets.hpp.template
+*x509_crt_bundle.bin

examples/esp32_pio/WebSocketClientSSLBundle/cmn_crt_authorities.csv

@@ -0,0 +1,39 @@
+Owner,Common Name or Certificate Name
+Amazon Trust Services,Amazon Root CA 1
+Amazon Trust Services,Amazon Root CA 2
+Amazon Trust Services,Amazon Root CA 3
+Amazon Trust Services,Amazon Root CA 4
+Amazon Trust Services,Starfield Services Root Certificate Authority - G2
+DigiCert,Baltimore CyberTrust Root
+DigiCert,Cybertrust Global Root
+DigiCert,DigiCert Assured ID Root CA
+DigiCert,DigiCert Assured ID Root G2
+DigiCert,DigiCert Assured ID Root G3
+DigiCert,DigiCert Global Root CA
+DigiCert,DigiCert Global Root G2
+DigiCert,DigiCert Global Root G3
+DigiCert,DigiCert High Assurance EV Root CA
+DigiCert,DigiCert Trusted Root G4
+GlobalSign,GlobalSign ECC Root CA - R5
+GlobalSign,GlobalSign Root CA - R3
+GlobalSign,GlobalSign Root CA - R6
+GlobalSign,GlobalSign Root CA
+GoDaddy,Go Daddy Class 2 CA
+GoDaddy,Go Daddy Root Certificate Authority - G2
+GoDaddy,Starfield Class 2 CA
+GoDaddy,Starfield Root Certificate Authority - G2
+Google Trust Services LLC (GTS),GlobalSign ECC Root CA - R4
+Google Trust Services LLC (GTS),GlobalSign Root CA - R2
+Google Trust Services LLC (GTS),GTS Root R1
+Google Trust Services LLC (GTS),GTS Root R2
+Google Trust Services LLC (GTS),GTS Root R3
+Google Trust Services LLC (GTS),GTS Root R4
+"IdenTrust Services, LLC",DST Root CA X3
+"IdenTrust Services, LLC",IdenTrust Commercial Root CA 1
+"IdenTrust Services, LLC",IdenTrust Public Sector Root CA 1
+Sectigo,Comodo AAA Services root
+Sectigo,COMODO Certification Authority
+Sectigo,COMODO ECC Certification Authority
+Sectigo,COMODO RSA Certification Authority
+Sectigo,USERTrust ECC Certification Authority
+Sectigo,USERTrust RSA Certification Authority

examples/esp32_pio/WebSocketClientSSLBundle/gen_crt_bundle.py

@@ -0,0 +1,227 @@
+#!/usr/bin/env python
+#
+# ESP32 x509 certificate bundle generation utility
+#
+# Converts PEM and DER certificates to a custom bundle format which stores just the
+# subject name and public key to reduce space
+#
+# The bundle will have the format: number of certificates; crt 1 subject name length; crt 1 public key length;
+# crt 1 subject name; crt 1 public key; crt 2...
+#
+# Copyright 2018-2019 Espressif Systems (Shanghai) PTE LTD
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http:#www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from __future__ import with_statement
+
+import argparse
+import csv
+import os
+import re
+import struct
+import sys
+from io import open
+
+try:
+    from cryptography import x509
+    from cryptography.hazmat.backends import default_backend
+    from cryptography.hazmat.primitives import serialization
+except ImportError:
+    print('The cryptography package is not installed.'
+          'Please refer to the Get Started section of the ESP-IDF Programming Guide for '
+          'setting up the required packages.')
+    raise
+
+ca_bundle_bin_file = 'x509_crt_bundle'
+
+quiet = False
+
+
+def status(msg):
+    """ Print status message to stderr """
+    if not quiet:
+        critical(msg)
+
+
+def critical(msg):
+    """ Print critical message to stderr """
+    sys.stderr.write('gen_crt_bundle.py: ')
+    sys.stderr.write(msg)
+    sys.stderr.write('\n')
+
+
+class CertificateBundle:
+    def __init__(self):
+        self.certificates = []
+        self.compressed_crts = []
+
+        if os.path.isfile(ca_bundle_bin_file):
+            os.remove(ca_bundle_bin_file)
+
+    def add_from_path(self, crts_path):
+
+        found = False
+        for file_path in os.listdir(crts_path):
+            found |= self.add_from_file(os.path.join(crts_path, file_path))
+
+        if found is False:
+            raise InputError('No valid x509 certificates found in %s' % crts_path)
+
+    def add_from_file(self, file_path):
+        try:
+            if file_path.endswith('.pem'):
+                status('Parsing certificates from %s' % file_path)
+                with open(file_path, 'r', encoding='utf-8') as f:
+                    crt_str = f.read()
+                    self.add_from_pem(crt_str)
+                    return True
+
+            elif file_path.endswith('.der'):
+                status('Parsing certificates from %s' % file_path)
+                with open(file_path, 'rb') as f:
+                    crt_str = f.read()
+                    self.add_from_der(crt_str)
+                    return True
+
+        except ValueError:
+            critical('Invalid certificate in %s' % file_path)
+            raise InputError('Invalid certificate')
+
+        return False
+
+    def add_from_pem(self, crt_str):
+        """ A single PEM file may have multiple certificates """
+
+        crt = ''
+        count = 0
+        start = False
+
+        for strg in crt_str.splitlines(True):
+            if strg == '-----BEGIN CERTIFICATE-----\n' and start is False:
+                crt = ''
+                start = True
+            elif strg == '-----END CERTIFICATE-----\n' and start is True:
+                crt += strg + '\n'
+                start = False
+                self.certificates.append(x509.load_pem_x509_certificate(crt.encode(), default_backend()))
+                count += 1
+            if start is True:
+                crt += strg
+
+        if(count == 0):
+            raise InputError('No certificate found')
+
+        status('Successfully added %d certificates' % count)
+
+    def add_from_der(self, crt_str):
+        self.certificates.append(x509.load_der_x509_certificate(crt_str, default_backend()))
+        status('Successfully added 1 certificate')
+
+    def create_bundle(self):
+        # Sort certificates in order to do binary search when looking up certificates
+        self.certificates = sorted(self.certificates, key=lambda cert: cert.subject.public_bytes(default_backend()))
+
+        bundle = struct.pack('>H', len(self.certificates))
+
+        for crt in self.certificates:
+            """ Read the public key as DER format """
+            pub_key = crt.public_key()
+            pub_key_der = pub_key.public_bytes(serialization.Encoding.DER, serialization.PublicFormat.SubjectPublicKeyInfo)
+
+            """ Read the subject name as DER format """
+            sub_name_der = crt.subject.public_bytes(default_backend())
+
+            name_len = len(sub_name_der)
+            key_len = len(pub_key_der)
+            len_data = struct.pack('>HH', name_len, key_len)
+
+            bundle += len_data
+            bundle += sub_name_der
+            bundle += pub_key_der
+
+        return bundle
+
+    def add_with_filter(self, crts_path, filter_path):
+
+        filter_set = set()
+        with open(filter_path, 'r', encoding='utf-8') as f:
+            csv_reader = csv.reader(f, delimiter=',')
+
+            # Skip header
+            next(csv_reader)
+            for row in csv_reader:
+                filter_set.add(row[1])
+
+        status('Parsing certificates from %s' % crts_path)
+        crt_str = []
+        with open(crts_path, 'r', encoding='utf-8') as f:
+            crt_str = f.read()
+
+            # Split all certs into a list of (name, certificate string) tuples
+            pem_crts = re.findall(r'(^.+?)\n(=+\n[\s\S]+?END CERTIFICATE-----\n)', crt_str, re.MULTILINE)
+
+            filtered_crts = ''
+            for name, crt in pem_crts:
+                if name in filter_set:
+                    filtered_crts += crt
+
+        self.add_from_pem(filtered_crts)
+
+
+class InputError(RuntimeError):
+    def __init__(self, e):
+        super(InputError, self).__init__(e)
+
+
+def main():
+    global quiet
+
+    parser = argparse.ArgumentParser(description='ESP-IDF x509 certificate bundle utility')
+
+    parser.add_argument('--quiet', '-q', help="Don't print non-critical status messages to stderr", action='store_true')
+    parser.add_argument('--input', '-i', nargs='+', required=True,
+                        help='Paths to the custom certificate folders or files to parse, parses all .pem or .der files')
+    parser.add_argument('--filter', '-f', help='Path to CSV-file where the second columns contains the name of the certificates \
+                        that should be included from cacrt_all.pem')
+
+    args = parser.parse_args()
+
+    quiet = args.quiet
+
+    bundle = CertificateBundle()
+
+    for path in args.input:
+        if os.path.isfile(path):
+            if os.path.basename(path) == 'cacrt_all.pem' and args.filter:
+                bundle.add_with_filter(path, args.filter)
+            else:
+                bundle.add_from_file(path)
+        elif os.path.isdir(path):
+            bundle.add_from_path(path)
+        else:
+            raise InputError('Invalid --input=%s, is neither file nor folder' % args.input)
+
+    status('Successfully added %d certificates in total' % len(bundle.certificates))
+
+    crt_bundle = bundle.create_bundle()
+
+    with open(ca_bundle_bin_file, 'wb') as f:
+        f.write(crt_bundle)
+
+
+if __name__ == '__main__':
+    try:
+        main()
+    except InputError as e:
+        print(e)
+        sys.exit(2)

examples/esp32_pio/WebSocketClientSSLBundle/lib/README

@@ -0,0 +1,46 @@
+
+This directory is intended for project specific (private) libraries.
+PlatformIO will compile them to static libraries and link into executable file.
+
+The source code of each library should be placed in a an own separate directory
+("lib/your_library_name/[here are source files]").
+
+For example, see a structure of the following two libraries `Foo` and `Bar`:
+
+|--lib
+|  |
+|  |--Bar
+|  |  |--docs
+|  |  |--examples
+|  |  |--src
+|  |     |- Bar.c
+|  |     |- Bar.h
+|  |  |- library.json (optional, custom build options, etc) https://docs.platformio.org/page/librarymanager/config.html
+|  |
+|  |--Foo
+|  |  |- Foo.c
+|  |  |- Foo.h
+|  |
+|  |- README --> THIS FILE
+|
+|- platformio.ini
+|--src
+   |- main.c
+
+and a contents of `src/main.c`:
+```
+#include <Foo.h>
+#include <Bar.h>
+
+int main (void)
+{
+  ...
+}
+
+```
+
+PlatformIO Library Dependency Finder will find automatically dependent
+libraries scanning project source files.
+
+More information about PlatformIO Library Dependency Finder
+- https://docs.platformio.org/page/librarymanager/ldf.html

examples/esp32_pio/WebSocketClientSSLBundle/platformio.ini

@@ -0,0 +1,25 @@
+; PlatformIO Project Configuration File
+;
+;   Build options: build flags, source filter
+;   Upload options: custom upload port, speed and extra flags
+;   Library options: dependencies, extra library storages
+;   Advanced options: extra scripting
+;
+; Please visit documentation for the other options and examples
+; https://docs.platformio.org/page/projectconf.html
+
+[env:esp32dev]
+platform = espressif32
+board = esp32dev
+framework = arduino
+monitor_speed = 115200
+upload_speed = 921600
+build_flags = 
+    -DCORE_DEBUG_LEVEL=5
+lib_deps = ../../../src
+
+extra_scripts = 
+    pre:run_gen_script.py
+
+board_build.embed_txtfiles = 
+    data/cert/x509_crt_bundle.bin

examples/esp32_pio/WebSocketClientSSLBundle/readme.md

@@ -0,0 +1,12 @@
+This is a PlatformIO project that uses a modified WiFiClientSecure library (in `lib`) to 
+implement proper SSL support using root certificates as discussed 
+[here](https://github.com/espressif/arduino-esp32/issues/3646#issuecomment-648292677)
+
+It is based on the work by [meltdonw03](https://github.com/meltdown03) in that thread, and the
+[BasicHttpsClient example](https://github.com/espressif/arduino-esp32/blob/1.0.4/libraries/HTTPClient/examples/BasicHttpsClient/BasicHttpsClient.ino) from the arduino-esp32 project.
+
+Just copy `include/secrets.hpp.template` to `include/secrets.hpp` and fill in your WiFi details.
+Then it should be pretty much ready to go. The local WiFiClientSecure library should take priority.
+Debug is set to verbose, so you'll see a lot of noise, but there should also be this readme on success :)
+
+To get a current CA cert bundle download it from [curl's website](https://curl.se/docs/caextract.html).

examples/esp32_pio/WebSocketClientSSLBundle/run_gen_script.py

@@ -0,0 +1,6 @@
+Import("env")
+
+env.Execute("$PYTHONEXE -m pip install cryptography")
+env.Execute("$PYTHONEXE gen_crt_bundle.py --input cacrt_all.pem")
+env.Execute("mkdir -p data/cert")
+env.Execute("mv -f x509_crt_bundle data/cert/x509_crt_bundle.bin")

examples/esp32_pio/WebSocketClientSSLBundle/src/main.cpp

@@ -0,0 +1,127 @@
+/*
+ * main.cpp
+ *
+ *  Created on: 15.06.2024
+ *
+ */
+
+#include <Arduino.h>
+#include <WiFi.h>
+#include <WiFiMulti.h>
+
+#include <WebSocketsClient.h>
+
+extern const uint8_t rootca_crt_bundle_start[] asm(
+    "_binary_data_cert_x509_crt_bundle_bin_start");
+
+WiFiMulti wifiMulti;
+WebSocketsClient webSocket;
+
+#define USE_SERIAL Serial
+
+void setClock() {
+    configTime(0, 0, "pool.ntp.org", "time.nist.gov");
+
+    USE_SERIAL.print(F("Waiting for NTP time sync: "));
+    time_t nowSecs = time(nullptr);
+    while(nowSecs < 8 * 3600 * 2) {
+        delay(500);
+        USE_SERIAL.print(F("."));
+        yield();
+        nowSecs = time(nullptr);
+    }
+
+    USE_SERIAL.println();
+    struct tm timeinfo;
+    gmtime_r(&nowSecs, &timeinfo);
+    USE_SERIAL.print(F("Current time: "));
+    USE_SERIAL.print(asctime(&timeinfo));
+}
+
+void hexdump(const void * mem, uint32_t len, uint8_t cols = 16) {
+    const uint8_t * src = (const uint8_t *)mem;
+    USE_SERIAL.printf("\n[HEXDUMP] Address: 0x%08X len: 0x%X (%d)", (ptrdiff_t)src, len, len);
+    for(uint32_t i = 0; i < len; i++) {
+        if(i % cols == 0) {
+            USE_SERIAL.printf("\n[0x%08X] 0x%08X: ", (ptrdiff_t)src, i);
+        }
+        USE_SERIAL.printf("%02X ", *src);
+        src++;
+    }
+    USE_SERIAL.printf("\n");
+}
+
+void webSocketEvent(WStype_t type, uint8_t * payload, size_t length) {
+    switch(type) {
+        case WStype_DISCONNECTED:
+            USE_SERIAL.printf("[WSc] Disconnected!\n");
+            break;
+        case WStype_CONNECTED:
+            USE_SERIAL.printf("[WSc] Connected to url: %s\n", payload);
+
+            // send message to server when Connected
+            webSocket.sendTXT("Connected");
+            break;
+        case WStype_TEXT:
+            USE_SERIAL.printf("[WSc] get text: %s\n", payload);
+
+            // send message to server
+            // webSocket.sendTXT("message here");
+            break;
+        case WStype_BIN:
+            USE_SERIAL.printf("[WSc] get binary length: %u\n", length);
+            hexdump(payload, length);
+
+            // send data to server
+            // webSocket.sendBIN(payload, length);
+            break;
+        case WStype_ERROR:
+        case WStype_FRAGMENT_TEXT_START:
+        case WStype_FRAGMENT_BIN_START:
+        case WStype_FRAGMENT:
+        case WStype_FRAGMENT_FIN:
+            break;
+    }
+}
+
+void setup() {
+    USE_SERIAL.begin(115200);
+
+    USE_SERIAL.setDebugOutput(true);
+
+    USE_SERIAL.println();
+    USE_SERIAL.println();
+    USE_SERIAL.println();
+
+    for(uint8_t t = 4; t > 0; t--) {
+        USE_SERIAL.printf("[SETUP] BOOT WAIT %d...\n", t);
+        USE_SERIAL.flush();
+        delay(1000);
+    }
+
+    wifiMulti.addAP("SSID", "WIFI_PASSPHRASE");
+
+    // WiFi.disconnect();
+    while(wifiMulti.run() != WL_CONNECTED) {
+        delay(100);
+    }
+
+    setClock();
+
+    // server address, port and URL. This server can be flakey.
+    // Expected response: Request served by 0123456789abcdef
+    webSocket.beginSslWithBundle("echo.websocket.org", 443, "/", rootca_crt_bundle_start, "");
+
+    // event handler
+    webSocket.onEvent(webSocketEvent);
+
+    // use HTTP Basic Authorization this is optional enable if needed
+    // webSocket.setAuthorization("user", "Password");
+
+    // try ever 5000 again if connection has failed
+    webSocket.setReconnectInterval(5000);
+}
+
+void loop() {
+    webSocket.loop();
+}

examples/esp8266_pico/WebSocketClient/WebSocketClient.ino

@@ -0,0 +1,106 @@
+/*
+ * WebSocketClient.ino
+ *
+ *  Created on: 24.05.2015
+ *
+ */
+
+#include <Arduino.h>
+
+#include <ESP8266WiFi.h>
+#include <ESP8266WiFiMulti.h>
+
+#include <WebSocketsClient.h>
+
+#include <Hash.h>
+
+ESP8266WiFiMulti WiFiMulti;
+WebSocketsClient webSocket;
+
+#define USE_SERIAL Serial1
+
+void webSocketEvent(WStype_t type, uint8_t * payload, size_t length) {
+
+	switch(type) {
+		case WStype_DISCONNECTED:
+			USE_SERIAL.printf("[WSc] Disconnected!\n");
+			break;
+		case WStype_CONNECTED: {
+			USE_SERIAL.printf("[WSc] Connected to url: %s\n", payload);
+
+			// send message to server when Connected
+			webSocket.sendTXT("Connected");
+		}
+			break;
+		case WStype_TEXT:
+			USE_SERIAL.printf("[WSc] get text: %s\n", payload);
+
+			// send message to server
+			// webSocket.sendTXT("message here");
+			break;
+		case WStype_BIN:
+			USE_SERIAL.printf("[WSc] get binary length: %u\n", length);
+			hexdump(payload, 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;
+    }
+
+}
+
+void setup() {
+	// USE_SERIAL.begin(921600);
+	USE_SERIAL.begin(115200);
+
+	//Serial.setDebugOutput(true);
+	USE_SERIAL.setDebugOutput(true);
+
+	USE_SERIAL.println();
+	USE_SERIAL.println();
+	USE_SERIAL.println();
+
+	for(uint8_t t = 4; t > 0; t--) {
+		USE_SERIAL.printf("[SETUP] BOOT WAIT %d...\n", t);
+		USE_SERIAL.flush();
+		delay(1000);
+	}
+
+	WiFiMulti.addAP("SSID", "passpasspass");
+
+	//WiFi.disconnect();
+	while(WiFiMulti.run() != WL_CONNECTED) {
+		delay(100);
+	}
+
+	// server address, port and URL
+	webSocket.begin("192.168.0.123", 81, "/");
+
+	// event handler
+	webSocket.onEvent(webSocketEvent);
+
+	// use HTTP Basic Authorization this is optional remove if not needed
+	webSocket.setAuthorization("user", "Password");
+
+	// 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);
+
+}
+
+void loop() {
+	webSocket.loop();
+}

examples/esp8266_pico/WebSocketClientOTA/README.md

@@ -0,0 +1,27 @@
+## Minimal example of WebsocketClientOTA and Python server
+
+Take this as small example, how achieve OTA update on ESP8266 and ESP32.
+
+Python server was wrote from train so take it only as bare example.
+It's working, but it's not mean to run in production.
+
+
+### Usage:
+
+Start server:
+```bash
+cd python_ota_server
+python3 -m venv .venv
+source .venv/bin/activate
+pip3 install -r requirements.txt
+python3 main.py
+```
+
+Flash ESP with example sketch and start it.
+
+Change version inside example sketch to higher and compile it and save it to bin file.
+
+Rename it to `mydevice-1.0.1-esp8266.bin` and place it inside new folder firmware (server create it).
+
+When the ESP connect to server, it check if version flashed is equal to fw in firmware folder. If higher FW version is present,
+start the flash process.

examples/esp8266_pico/WebSocketClientOTA/WebSocketClientOTA.ino

@@ -0,0 +1,264 @@
+/*
+ * WebSocketClientOTA.ino
+ *
+ *  Created on: 25.10.2021
+ *
+ */
+
+#include <Arduino.h>
+#include <ArduinoJson.h>
+
+#if defined(ESP8266)
+    #include <ESP8266WiFi.h>
+    #include <ESP8266WiFiMulti.h>
+    #include <ESP8266mDNS.h>
+    #include <Updater.h>
+    #include <Hash.h>
+
+    ESP8266WiFiMulti WiFiMulti;
+#elif defined(ESP32)
+    #include <WiFi.h>
+    #include <WiFiMulti.h>
+    #include "ESPmDNS.h"
+    #include <Update.h>
+
+    WiFiMulti WiFiMulti;
+#else
+    #error Unsupported device
+#endif
+
+#include <WiFiUdp.h>
+#include <WebSocketsClient.h>
+
+
+WebSocketsClient webSocket;
+
+#define USE_SERIAL Serial
+
+// Variables:
+// Settable:
+const char *version = "1.0.0";
+const char *name = "mydevice";
+
+// Others:
+#ifdef ESP8266
+	const char *chip = "esp8266";
+#endif
+#ifdef ESP32
+	const char *chip = "esp32";
+#endif
+
+uint32_t maxSketchSpace = 0;
+int SketchSize = 0;
+bool ws_conn = false;
+
+
+void greetings_(){
+	StaticJsonDocument<200> doc;
+	doc["type"] = "greetings";
+	doc["mac"] = WiFi.macAddress().c_str();
+	doc["ip"] = WiFi.localIP().toString().c_str();
+	doc["version"] = version;
+	doc["name"] = name;
+	doc["chip"] = chip;
+
+	char data[200];
+	serializeJson(doc, data);
+	webSocket.sendTXT(data);
+}
+
+void register_(){
+	StaticJsonDocument<200> doc;
+	doc["type"] = "register";
+    doc["mac"] = WiFi.macAddress().c_str();
+
+	char data[200];
+	serializeJson(doc, data);
+	webSocket.sendTXT(data);
+    ws_conn = true;
+}
+
+typedef void (*CALLBACK_FUNCTION)(JsonDocument &msg);
+
+typedef struct {
+   char  type[50];
+   CALLBACK_FUNCTION  func;
+} RESPONSES_STRUCT;
+
+void OTA_RESPONSES(JsonDocument &msg){
+    USE_SERIAL.print(F("[WSc] OTA mode: "));
+    String val = msg["value"];
+    if(val == "go") {
+        USE_SERIAL.print(F("go\n"));
+        SketchSize = int(msg["size"]);
+        maxSketchSpace = (ESP.getFreeSketchSpace() - 0x1000) & 0xFFFFF000;
+        USE_SERIAL.printf("[WSc] Max sketch size: %u\n", maxSketchSpace);
+        USE_SERIAL.printf("[WSc] Sketch size: %d\n", SketchSize);
+        USE_SERIAL.setDebugOutput(true);
+        if (!Update.begin(maxSketchSpace)) { //start with max available size
+            Update.printError(Serial);
+            ESP.restart();
+        }
+    } else if (val == "ok") {
+        USE_SERIAL.print(F("OK\n"));
+        register_();
+    } else {
+        USE_SERIAL.print(F("unknown value : "));
+        USE_SERIAL.print(val);
+        USE_SERIAL.print(F("\n"));
+    }
+}
+
+void STA_RESPONSES(JsonDocument &msg){
+    // Do something with message
+}
+
+// Count of responses handled by RESPONSES_STRUCT
+// increase increase if another response handler is added
+const int nrOfResponses = 2;
+
+RESPONSES_STRUCT responses[nrOfResponses] = {
+  {"ota",        OTA_RESPONSES},
+  {"state",      STA_RESPONSES},
+};
+
+void text(uint8_t * payload, size_t length){
+    // Convert message to something usable
+    char msgch[length];
+    for (unsigned int i = 0; i < length; i++)
+    {
+        USE_SERIAL.print((char)payload[i]);
+        msgch[i] = ((char)payload[i]);
+    }
+    msgch[length] = '\0';
+
+    // Parse Json
+    StaticJsonDocument<200> doc_in;
+    DeserializationError error = deserializeJson(doc_in, msgch);
+
+    if (error) {
+        USE_SERIAL.print(F("deserializeJson() failed: "));
+        USE_SERIAL.println(error.c_str());
+        return;
+    }
+
+    // Handle each TYPE of message
+    int b = 0;
+
+    String t = doc_in["type"];
+    for( b=0 ; b<nrOfResponses ; b++ )
+    {
+        if(t == responses[b].type) {
+            responses[b].func(doc_in);
+        }
+    }
+}
+
+void webSocketEvent(WStype_t type, uint8_t * payload, size_t length) {
+
+	switch(type) {
+		case WStype_DISCONNECTED:
+			USE_SERIAL.printf("[WSc] Disconnected!\n");
+			break;
+		case WStype_CONNECTED: {
+			USE_SERIAL.printf("[WSc] Connected to url: %s\n", payload);
+
+			// send message to server when Connected
+			// webSocket.sendTXT("Connected");
+			greetings_();
+		}
+			break;
+		case WStype_TEXT:
+			USE_SERIAL.printf("[WSc] get text: %s\n", payload);
+
+			// send message to server
+			// webSocket.sendTXT("message here");
+			text(payload, length);
+			break;
+		case WStype_BIN:
+			USE_SERIAL.printf("[WSc] get binary length: %u\n", length);
+			// hexdump(payload, length);
+	        if (Update.write(payload, length) != length) {
+                Update.printError(Serial);
+                ESP.restart();
+            }
+            yield();
+            SketchSize -= length;
+            USE_SERIAL.printf("[WSc] Sketch size left: %u\n", SketchSize);
+            if (SketchSize < 1){
+                if (Update.end(true)) { //true to set the size to the current progress
+                    USE_SERIAL.printf("Update Success: \nRebooting...\n");
+                    delay(5);
+                    yield();
+                    ESP.restart();
+                } else {
+                    Update.printError(USE_SERIAL);
+                    ESP.restart();
+                }
+                USE_SERIAL.setDebugOutput(false);
+            }
+
+			// 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;
+    }
+
+}
+
+void setup() {
+	// USE_SERIAL.begin(921600);
+	USE_SERIAL.begin(115200);
+
+	//Serial.setDebugOutput(true);
+	USE_SERIAL.setDebugOutput(true);
+
+	USE_SERIAL.print(F("\nMAC: "));
+	USE_SERIAL.println(WiFi.macAddress());
+	USE_SERIAL.print(F("\nDevice: "));
+	USE_SERIAL.println(name);
+	USE_SERIAL.printf("\nVersion: %s\n", version);
+
+	for(uint8_t t = 4; t > 0; t--) {
+		USE_SERIAL.printf("[SETUP] BOOT WAIT %d...\n", t);
+		USE_SERIAL.flush();
+		delay(1000);
+	}
+
+	WiFiMulti.addAP("SSID", "PASS");
+
+	//WiFi.disconnect();
+	while(WiFiMulti.run() != WL_CONNECTED) {
+		delay(100);
+	}
+
+	// server address, port and URL
+	webSocket.begin("10.0.1.5", 8081, "/");
+
+	// event handler
+	webSocket.onEvent(webSocketEvent);
+
+	// use HTTP Basic Authorization this is optional remove if not needed
+	// webSocket.setAuthorization("USER", "PASS");
+
+	// 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);
+
+}
+
+void loop() {
+	webSocket.loop();
+}

examples/esp8266_pico/WebSocketClientOTA/python_ota_server/main.py

@@ -0,0 +1,235 @@
+"""Minimal example of Python websocket server
+handling OTA updates for ESP32 amd ESP8266
+
+Check and upload of firmware works.
+Register and state function are jus for example.
+"""
+# pylint: disable=W0703,E1101
+import asyncio
+import copy
+import json
+import logging
+import subprocess
+import threading
+import time
+from os import listdir
+from os.path import join as join_pth
+from pathlib import Path
+
+import websockets
+from packaging import version
+
+# Logger settings
+logging.basicConfig(filename="ws_server.log")
+Logger = logging.getLogger('WS-OTA')
+Logger.addHandler(logging.StreamHandler())
+Logger.setLevel(logging.INFO)
+
+# Path to directory with FW
+fw_path = join_pth(Path().absolute(), "firmware")
+
+
+def create_path(path: str) -> None:
+    """Check if path exist or create it"""
+    Path(path).mkdir(parents=True, exist_ok=True)
+
+
+def shell(command):
+    """Handle execution of shell commands"""
+    with subprocess.Popen(command, shell=True,
+                          stdout=subprocess.PIPE,
+                          universal_newlines=True
+                          ) as process:
+        for stdout_line in iter(process.stdout.readline, ""):
+            Logger.debug(stdout_line)
+        process.stdout.close()
+        return_code = process.wait()
+        Logger.debug("Shell returned: %s", return_code)
+
+        return process.returncode
+    return None
+
+
+async def binary_send(websocket, fw_file):
+    """Read firmware file, divide it to chunks and send them"""
+    with open(fw_file, "rb") as binaryfile:
+
+        while True:
+            chunk = binaryfile.read(4096)
+            if not chunk:
+                break
+            try:
+                await websocket.send(chunk)
+            except Exception as exception:
+                Logger.exception(exception)
+                return False
+            asyncio.sleep(0.2)
+
+
+def version_checker(name, vdev, vapp):
+    """Parse and compare FW version"""
+
+    if version.parse(vdev) < version.parse(vapp):
+        Logger.info("Client(%s) version %s is smaller than %s: Go for update", name, vdev, vapp)
+        return True
+    Logger.info("Client(%s) version %s is greater or equal to %s: Not updating", name, vdev, vapp)
+    return False
+
+
+class WsOtaHandler (threading.Thread):
+    """Thread handling ota update
+
+    Running ota directly from message would kill WS
+    as message bus would timeout.
+    """
+    def __init__(self, name, message, websocket):
+        threading.Thread.__init__(self, daemon=True)
+        self.name = name
+        self.msg = message
+        self.websocket = websocket
+
+    def run(self, ):
+        try:
+            asyncio.run(self.start_())
+        except Exception as exception:
+            Logger.exception(exception)
+        finally:
+            pass
+
+    async def start_(self):
+        """Start _ota se asyncio future"""
+        msg_task = asyncio.ensure_future(
+            self._ota())
+
+        done, pending = await asyncio.wait(
+            [msg_task],
+            return_when=asyncio.FIRST_COMPLETED,
+        )
+        Logger.info("WS Ota Handler done: %s", done)
+        for task in pending:
+            task.cancel()
+
+    async def _ota(self):
+        """Check for new fw and update or pass"""
+        device_name = self.msg['name']
+        device_chip = self.msg['chip']
+        device_version = self.msg['version']
+        fw_version = ''
+        fw_name = ''
+        fw_device = ''
+
+        for filename in listdir(fw_path):
+            fw_info = filename.split("-")
+            fw_device = fw_info[0]
+            if fw_device == device_name:
+                fw_version = fw_info[1]
+                fw_name = filename
+                break
+
+        if not fw_version:
+            Logger.info("Client(%s): No fw found!", device_name)
+            msg = '{"type": "ota", "value":"ok"}'
+            await self.websocket.send(msg)
+            return
+
+        if not version_checker(device_name, device_version, fw_version):
+            return
+
+        fw_file = join_pth(fw_path, fw_name)
+        if device_chip == 'esp8266' and not fw_file.endswith('.gz'):
+            # We can compress fw to make it smaller for upload
+            fw_cpress = fw_file
+            fw_file = fw_cpress + ".gz"
+            cpress = f"gzip -9 {fw_cpress}"
+            cstate = shell(cpress)
+            if cstate:
+                Logger.error("Cannot compress firmware: %s", fw_name)
+                return
+
+        # Get size of fw
+        size = Path(fw_file).stat().st_size
+
+        # Request ota mode
+        msg = '{"type": "ota", "value":"go", "size":' + str(size) + '}'
+        await self.websocket.send(msg)
+
+        # send file by chunks trough websocket
+        await binary_send(self.websocket, fw_file)
+
+
+async def _register(websocket, message):
+    mac = message.get('mac')
+    name = message.get('name')
+    Logger.info("Client(%s) mac: %s", name, mac)
+    # Some code
+
+    response = {'type': 'registry', 'state': 'ok'}
+    await websocket.send(json.dumps(response))
+
+
+async def _state(websocket, message):
+    mac = message.get('mac')
+    name = message.get('name')
+    Logger.info("Client(%s) mac: %s", name, mac)
+    # Some code
+
+    response = {'type': 'state', 'state': 'ok'}
+    await websocket.send(json.dumps(response))
+
+
+async def _unhandled(websocket, msg):
+    Logger.info("Unhandled message from device: %s", str(msg))
+    response = {'type': 'response', 'state': 'nok'}
+    await websocket.send(json.dumps(response))
+
+
+async def _greetings(websocket, message):
+    WsOtaHandler('thread_ota', copy.deepcopy(message), websocket).start()
+
+
+async def message_received(websocket, message) -> None:
+    """Handle incoming messages
+
+    Check if message contain json and run waned function
+    """
+    switcher = {"greetings": _greetings,
+                "register":  _register,
+                "state":     _state
+                }
+
+    if message[0:1] == "{":
+        try:
+            msg_json = json.loads(message)
+        except Exception as exception:
+            Logger.error(exception)
+            return
+
+        type_ = msg_json.get('type')
+        name = msg_json.get('name')
+        func = switcher.get(type_, _unhandled)
+        Logger.debug("Client(%s)said: %s", name, type_)
+
+        try:
+            await func(websocket, msg_json)
+        except Exception as exception:
+            Logger.error(exception)
+
+
+# pylint: disable=W0613
+async def ws_server(websocket, path) -> None:
+    """Run in cycle and wait for new messages"""
+    async for message in websocket:
+        await message_received(websocket, message)
+
+
+async def main():
+    """Server starter
+
+    Normal user can bind only port numbers greater than 1024
+    """
+    async with websockets.serve(ws_server, "10.0.1.5", 8081):
+        await asyncio.Future()  # run forever
+
+
+create_path(fw_path)
+asyncio.run(main())

examples/esp8266_pico/WebSocketClientOTA/python_ota_server/requirements.txt

@@ -0,0 +1,2 @@
+packaging
+websockets

examples/esp8266_pico/WebSocketClientSSL/WebSocketClientSSL.ino

@@ -1,7 +1,9 @@
 /*
- * WebSocketClient.ino
+ * WebSocketClientSSL.ino
  *
- *  Created on: 24.05.2015
+ *  Created on: 10.12.2015
+ *
+ *  note SSL is only possible with the ESP8266
  *
  */
 
@@ -20,7 +22,7 @@ WebSocketsClient webSocket;
 
 #define USE_SERIAL Serial1
 
-void webSocketEvent(WStype_t type, uint8_t * payload, size_t lenght) {
+void webSocketEvent(WStype_t type, uint8_t * payload, size_t length) {
 
 
     switch(type) {
@@ -30,26 +32,28 @@ void webSocketEvent(WStype_t type, uint8_t * payload, size_t lenght) {
         case WStype_CONNECTED:
             {
                 USE_SERIAL.printf("[WSc] Connected to url: %s\n",  payload);
+				
+			    // send message to server when Connected
+				webSocket.sendTXT("Connected");
             }
             break;
         case WStype_TEXT:
             USE_SERIAL.printf("[WSc] get text: %s\n", payload);
 
-            // send data to back to Server
-            webSocket.sendTXT(payload, lenght);
+			// send message to server
+			// webSocket.sendTXT("message here");
             break;
         case WStype_BIN:
-            USE_SERIAL.printf("[WSc] get binary lenght: %u\n", lenght);
-            hexdump(payload, lenght);
+            USE_SERIAL.printf("[WSc] get binary length: %u\n", length);
+            hexdump(payload, length);
 
-            // echo data back to Server
-            webSocket.sendBIN(payload, lenght);
+            // send data to server
+            // webSocket.sendBIN(payload, length);
             break;
     }
 
 }
 
-
 void setup() {
     // USE_SERIAL.begin(921600);
     USE_SERIAL.begin(115200);
@@ -74,13 +78,11 @@ void setup() {
         delay(100);
     }
 
-    webSocket.begin("192.168.0.123", 81);
+    webSocket.beginSSL("192.168.0.123", 81);
     webSocket.onEvent(webSocketEvent);
 
 }
 
-
-
 void loop() {
     webSocket.loop();
 }

examples/esp8266_pico/WebSocketClientSSLWithCA/WebSocketClientSSLWithCA.ino

@@ -0,0 +1,103 @@
+/*
+ * WebSocketClientSSLWithCA.ino
+ *
+ *  Created on: 27.10.2019
+ *
+ *  note SSL is only possible with the ESP8266
+ *
+ */
+
+#include <Arduino.h>
+
+#include <ESP8266WiFi.h>
+#include <ESP8266WiFiMulti.h>
+
+#include <WebSocketsClient.h>
+
+ESP8266WiFiMulti WiFiMulti;
+WebSocketsClient webSocket;
+
+#define USE_SERIAL Serial1
+
+
+// Can be obtained with:
+//  openssl s_client -showcerts -connect echo.websocket.org:443 </dev/null
+const char ENDPOINT_CA_CERT[] PROGMEM = R"EOF(
+-----BEGIN CERTIFICATE-----
+MIIEkjCCA3qgAwIBAgIQCgFBQgAAAVOFc2oLheynCDANBgkqhkiG9w0BAQsFADA/MSQwIgYDVQQKExtEaWdpdGFsIFNpZ25hdHVyZSBUcnVzdCBDby4xFzAVBgNVBAMT
+DkRTVCBSb290IENBIFgzMB4XDTE2MDMxNzE2NDA0NloXDTIxMDMxNzE2NDA0NlowSjELMAkGA1UEBhMCVVMxFjAUBgNVBAoTDUxldCdzIEVuY3J5cHQxIzAhBgNVBAMT
+GkxldCdzIEVuY3J5cHQgQXV0aG9yaXR5IFgzMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAnNMM8FrlLke3cl03g7NoYzDq1zUmGSXhvb418XCSL7e4S0EF
+q6meNQhY7LEqxGiHC6PjdeTm86dicbp5gWAf15Gan/PQeGdxyGkOlZHP/uaZ6WA8SMx+yk13EiSdRxta67nsHjcAHJyse6cF6s5K671B5TaYucv9bTyWaN8jKkKQDIZ0
+Z8h/pZq4UmEUEz9l6YKHy9v6Dlb2honzhT+Xhq+w3Brvaw2VFn3EK6BlspkENnWAa6xK8xuQSXgvopZPKiAlKQTGdMDQMc2PMTiVFrqoM7hD8bEfwzB/onkxEz0tNvjj
+/PIzark5McWvxI0NHWQWM6r6hCm21AvA2H3DkwIDAQABo4IBfTCCAXkwEgYDVR0TAQH/BAgwBgEB/wIBADAOBgNVHQ8BAf8EBAMCAYYwfwYIKwYBBQUHAQEEczBxMDIG
+CCsGAQUFBzABhiZodHRwOi8vaXNyZy50cnVzdGlkLm9jc3AuaWRlbnRydXN0LmNvbTA7BggrBgEFBQcwAoYvaHR0cDovL2FwcHMuaWRlbnRydXN0LmNvbS9yb290cy9k
+c3Ryb290Y2F4My5wN2MwHwYDVR0jBBgwFoAUxKexpHsscfrb4UuQdf/EFWCFiRAwVAYDVR0gBE0wSzAIBgZngQwBAgEwPwYLKwYBBAGC3xMBAQEwMDAuBggrBgEFBQcC
+ARYiaHR0cDovL2Nwcy5yb290LXgxLmxldHNlbmNyeXB0Lm9yZzA8BgNVHR8ENTAzMDGgL6AthitodHRwOi8vY3JsLmlkZW50cnVzdC5jb20vRFNUUk9PVENBWDNDUkwu
+Y3JsMB0GA1UdDgQWBBSoSmpjBH3duubRObemRWXv86jsoTANBgkqhkiG9w0BAQsFAAOCAQEA3TPXEfNjWDjdGBX7CVW+dla5cEilaUcne8IkCJLxWh9KEik3JHRRHGJo
+uM2VcGfl96S8TihRzZvoroed6ti6WqEBmtzw3Wodatg+VyOeph4EYpr/1wXKtx8/wApIvJSwtmVi4MFU5aMqrSDE6ea73Mj2tcMyo5jMd6jmeWUHK8so/joWUoHOUgwu
+X4Po1QYz+3dszkDqMp4fklxBwXRsW10KXzPMTZ+sOPAveyxindmjkW8lGy+QsRlGPfZ+G6Z6h7mjem0Y+iWlkYcV4PIWL1iwBi8saCbGS5jN2p8M+X+Q7UNKEkROb3N6
+KOqkqm57TH2H3eDJAkSnh6/DNFu0Qg==
+-----END CERTIFICATE-----
+)EOF";
+
+void webSocketEvent(WStype_t type, uint8_t * payload, size_t length) {
+    switch(type) {
+        case WStype_DISCONNECTED:
+            USE_SERIAL.printf("[WSc] Disconnected!\n");
+            break;
+        case WStype_CONNECTED:
+            {
+                USE_SERIAL.printf("[WSc] Connected to url: %s\n",  payload);
+
+                // send message to server when Connected
+                webSocket.sendTXT("Connected");
+            }
+            break;
+        case WStype_TEXT:
+            USE_SERIAL.printf("[WSc] get text: %s\n", payload);
+
+            // send message to server
+            // webSocket.sendTXT("message here");
+            break;
+        case WStype_BIN:
+            USE_SERIAL.printf("[WSc] get binary length: %u\n", length);
+            hexdump(payload, length);
+
+            // send data to server
+            // webSocket.sendBIN(payload, length);
+            break;
+    }
+}
+
+void setup() {
+    USE_SERIAL.begin(115200);
+
+    USE_SERIAL.setDebugOutput(true);
+
+    USE_SERIAL.println();
+    USE_SERIAL.println();
+    USE_SERIAL.println();
+
+    for(uint8_t t = 4; t > 0; t--) {
+        USE_SERIAL.printf("[SETUP] BOOT WAIT %d...\n", t);
+        USE_SERIAL.flush();
+        delay(1000);
+    }
+
+    WiFiMulti.addAP("SSID", "passpasspass");
+
+    while(WiFiMulti.run() != WL_CONNECTED) {
+        delay(100);
+    }
+
+    //When using BearSSL, client certificate and private key can be set:
+    //webSocket.setSSLClientCertKey(clientCert, clientPrivateKey);
+    //clientCert and clientPrivateKey can be of types (const char *, const char *) , or of types (BearSSL::X509List, BearSSL::PrivateKey)
+    
+    webSocket.beginSslWithCA("echo.websocket.org", 443, "/", ENDPOINT_CA_CERT);
+    webSocket.onEvent(webSocketEvent);
+}
+
+void loop() {
+    webSocket.loop();
+}

examples/esp8266_pico/WebSocketClientSocketIO/WebSocketClientSocketIO.ino

@@ -0,0 +1,128 @@
+/*
+ * WebSocketClientSocketIO.ino
+ *
+ *  Created on: 06.06.2016
+ *
+ */
+
+#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 Serial1
+
+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);
+
+            // join default namespace (no auto join in Socket.IO V3)
+            socketIO.send(sIOtype_CONNECT, "/");
+            break;
+        case sIOtype_EVENT:
+            USE_SERIAL.printf("[IOc] get event: %s\n", payload);
+            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, "/socket.io/?EIO=4");
+
+    // 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"] = (uint32_t) 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_pico/WebSocketClientSocketIOack/WebSocketClientSocketIOack.ino

@@ -0,0 +1,165 @@
+/*
+ * 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);
+
+            // join default namespace (no auto join in Socket.IO V3)
+            socketIO.send(sIOtype_CONNECT, "/");
+            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, "/socket.io/?EIO=4");
+
+    // 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"] = (uint32_t) 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_pico/WebSocketClientStomp/WebSocketClientStomp.ino

@@ -0,0 +1,149 @@
+/*
+    WebSocketClientStomp.ino
+
+    Example for connecting and maintining a connection with a STOMP websocket connection.
+    In this example, we connect to a Spring application (see https://docs.spring.io/spring/docs/current/spring-framework-reference/html/websocket.html).
+
+    Created on: 25.09.2017
+    Author: Martin Becker <mgbckr>, Contact: becker@informatik.uni-wuerzburg.de
+*/
+
+// PRE
+
+#define USE_SERIAL Serial
+
+
+// LIBRARIES
+
+#include <Arduino.h>
+#include <Hash.h>
+
+#include <ESP8266WiFi.h>
+#include <WebSocketsClient.h>
+
+
+// SETTINGS
+
+const char* wlan_ssid             = "yourssid";
+const char* wlan_password         = "somepassword";
+
+const char* ws_host               = "the.host.net";
+const int   ws_port               = 80;
+
+// URL for STOMP endpoint.
+// For the default config of Spring's STOMP support, the default URL is "/socketentry/websocket".
+const char* stompUrl            = "/socketentry/websocket"; // don't forget the leading "/" !!!
+
+
+// VARIABLES
+
+WebSocketsClient webSocket;
+
+
+// FUNCTIONS
+
+/**
+ * STOMP messages need to be NULL-terminated (i.e., \0 or \u0000).
+ * However, when we send a String or a char[] array without specifying 
+ * a length, the size of the message payload is derived by strlen() internally,
+ * thus dropping any NULL values appended to the "msg"-String.
+ * 
+ * To solve this, we first convert the String to a NULL terminated char[] array
+ * via "c_str" and set the length of the payload to include the NULL value.
+ */
+void sendMessage(String & msg) {
+    webSocket.sendTXT(msg.c_str(), msg.length() + 1);
+}
+
+void webSocketEvent(WStype_t type, uint8_t * payload, size_t length) {
+
+    switch (type) {
+        case WStype_DISCONNECTED:
+            USE_SERIAL.printf("[WSc] Disconnected!\n");
+            break;
+        case WStype_CONNECTED:
+            {
+                USE_SERIAL.printf("[WSc] Connected to url: %s\n",  payload);
+                
+                String msg = "CONNECT\r\naccept-version:1.1,1.0\r\nheart-beat:10000,10000\r\n\r\n";
+                sendMessage(msg);
+            }
+            break;
+        case WStype_TEXT:
+            {
+                // #####################
+                // handle STOMP protocol
+                // #####################
+
+                String text = (char*) payload;
+                USE_SERIAL.printf("[WSc] get text: %s\n", payload);
+
+                if (text.startsWith("CONNECTED")) {
+
+                    // subscribe to some channels
+
+                    String msg = "SUBSCRIBE\nid:sub-0\ndestination:/user/queue/messages\n\n";
+                    sendMessage(msg);
+                    delay(1000);
+
+                    // and send a message
+
+                    msg = "SEND\ndestination:/app/message\n\n{\"user\":\"esp\",\"message\":\"Hello!\"}";
+                    sendMessage(msg);
+                    delay(1000);
+                    
+                } else {
+
+                    // do something with messages
+                    
+                }
+
+                break;
+            }
+        case WStype_BIN:
+            USE_SERIAL.printf("[WSc] get binary length: %u\n", length);
+            hexdump(payload, length);
+
+            // send data to server
+            // webSocket.sendBIN(payload, length);
+            break;
+    }
+
+}
+
+void setup() {
+
+    // setup serial
+
+    // USE_SERIAL.begin(921600);
+    USE_SERIAL.begin(115200);
+
+    //    USE_SERIAL.setDebugOutput(true);
+
+    USE_SERIAL.println();
+
+
+    // connect to WiFi
+
+    USE_SERIAL.print("Logging into WLAN: "); Serial.print(wlan_ssid); Serial.print(" ...");
+    WiFi.mode(WIFI_STA);
+    WiFi.begin(wlan_ssid, wlan_password);
+
+    while (WiFi.status() != WL_CONNECTED) {
+        delay(500);
+        USE_SERIAL.print(".");
+    }
+    USE_SERIAL.println(" success.");
+    USE_SERIAL.print("IP: "); USE_SERIAL.println(WiFi.localIP());
+
+
+    // connect to websocket
+    webSocket.begin(ws_host, ws_port, stompUrl);
+    webSocket.setExtraHeaders(); // remove "Origin: file://" header because it breaks the connection with Spring's default websocket config
+    //    webSocket.setExtraHeaders("foo: I am so funny\r\nbar: not"); // some headers, in case you feel funny
+    webSocket.onEvent(webSocketEvent);
+}
+
+void loop() {
+    webSocket.loop();
+}

examples/esp8266_pico/WebSocketClientStompOverSockJs/WebSocketClientStompOverSockJs.ino

@@ -0,0 +1,150 @@
+/*
+    WebSocketClientStompOverSockJs.ino
+
+    Example for connecting and maintining a connection with a SockJS+STOMP websocket connection.
+    In this example, we connect to a Spring application (see https://docs.spring.io/spring/docs/current/spring-framework-reference/html/websocket.html).
+
+    Created on: 18.07.2017
+    Author: Martin Becker <mgbckr>, Contact: becker@informatik.uni-wuerzburg.de
+*/
+
+// PRE
+
+#define USE_SERIAL Serial
+
+
+// LIBRARIES
+
+#include <Arduino.h>
+#include <Hash.h>
+
+#include <ESP8266WiFi.h>
+#include <WebSocketsClient.h>
+
+
+// SETTINGS
+
+const char* wlan_ssid             = "yourssid";
+const char* wlan_password         = "somepassword";
+
+const char* ws_host               = "the.host.net";
+const int   ws_port               = 80;
+
+// base URL for SockJS (websocket) connection
+// The complete URL will look something like this(cf. http://sockjs.github.io/sockjs-protocol/sockjs-protocol-0.3.3.html#section-36):
+// ws://<ws_host>:<ws_port>/<ws_baseurl>/<3digits>/<randomstring>/websocket
+// For the default config of Spring's SockJS/STOMP support, the default base URL is "/socketentry/".
+const char* ws_baseurl            = "/socketentry/"; // don't forget leading and trailing "/" !!!
+
+
+// VARIABLES
+
+WebSocketsClient webSocket;
+
+
+// FUNCTIONS
+
+void webSocketEvent(WStype_t type, uint8_t * payload, size_t length) {
+
+    switch (type) {
+        case WStype_DISCONNECTED:
+            USE_SERIAL.printf("[WSc] Disconnected!\n");
+            break;
+        case WStype_CONNECTED:
+            {
+                USE_SERIAL.printf("[WSc] Connected to url: %s\n",  payload);
+            }
+            break;
+        case WStype_TEXT:
+            {
+                // #####################
+                // handle SockJs+STOMP protocol
+                // #####################
+
+                String text = (char*) payload;
+
+                USE_SERIAL.printf("[WSc] get text: %s\n", payload);
+
+                if (payload[0] == 'h') {
+
+                    USE_SERIAL.println("Heartbeat!");
+
+                } else if (payload[0] == 'o') {
+
+                    // on open connection
+                    char *msg = "[\"CONNECT\\naccept-version:1.1,1.0\\nheart-beat:10000,10000\\n\\n\\u0000\"]";
+                    webSocket.sendTXT(msg);
+
+                } else if (text.startsWith("a[\"CONNECTED")) {
+
+                    // subscribe to some channels
+
+                    char *msg = "[\"SUBSCRIBE\\nid:sub-0\\ndestination:/user/queue/messages\\n\\n\\u0000\"]";
+                    webSocket.sendTXT(msg);
+                    delay(1000);
+
+                    // and send a message
+
+                    msg = "[\"SEND\\ndestination:/app/message\\n\\n{\\\"user\\\":\\\"esp\\\",\\\"message\\\":\\\"Hello!\\\"}\\u0000\"]";
+                    webSocket.sendTXT(msg);
+                    delay(1000);
+                }
+
+                break;
+            }
+        case WStype_BIN:
+            USE_SERIAL.printf("[WSc] get binary length: %u\n", length);
+            hexdump(payload, length);
+
+            // send data to server
+            // webSocket.sendBIN(payload, length);
+            break;
+    }
+
+}
+
+void setup() {
+
+    // setup serial
+
+    // USE_SERIAL.begin(921600);
+    USE_SERIAL.begin(115200);
+
+    //    USE_SERIAL.setDebugOutput(true);
+
+    USE_SERIAL.println();
+
+
+    // connect to WiFi
+
+    USE_SERIAL.print("Logging into WLAN: "); Serial.print(wlan_ssid); Serial.print(" ...");
+    WiFi.mode(WIFI_STA);
+    WiFi.begin(wlan_ssid, wlan_password);
+
+    while (WiFi.status() != WL_CONNECTED) {
+        delay(500);
+        USE_SERIAL.print(".");
+    }
+    USE_SERIAL.println(" success.");
+    USE_SERIAL.print("IP: "); USE_SERIAL.println(WiFi.localIP());
+
+
+    // #####################
+    // create socket url according to SockJS protocol (cf. http://sockjs.github.io/sockjs-protocol/sockjs-protocol-0.3.3.html#section-36)
+    // #####################
+    String socketUrl = ws_baseurl;
+    socketUrl += random(0, 999);
+    socketUrl += "/";
+    socketUrl += random(0, 999999); // should be a random string, but this works (see )
+    socketUrl += "/websocket";
+
+    // connect to websocket
+    webSocket.begin(ws_host, ws_port, socketUrl);
+    webSocket.setExtraHeaders(); // remove "Origin: file://" header because it breaks the connection with Spring's default websocket config
+    //    webSocket.setExtraHeaders("foo: I am so funny\r\nbar: not"); // some headers, in case you feel funny
+    webSocket.onEvent(webSocketEvent);
+}
+
+void loop() {
+    webSocket.loop();
+}

examples/esp8266_pico/WebSocketServer/WebSocketServer.ino

@@ -18,7 +18,7 @@ WebSocketsServer webSocket = WebSocketsServer(81);
 
 #define USE_SERIAL Serial1
 
-void webSocketEvent(uint8_t num, WStype_t type, uint8_t * payload, size_t lenght) {
+void webSocketEvent(uint8_t num, WStype_t type, uint8_t * payload, size_t length) {
 
     switch(type) {
         case WStype_DISCONNECTED:
@@ -28,23 +28,26 @@ void webSocketEvent(uint8_t num, WStype_t type, uint8_t * payload, size_t lenght
             {
                 IPAddress ip = webSocket.remoteIP(num);
                 USE_SERIAL.printf("[%u] Connected from %d.%d.%d.%d url: %s\n", num, ip[0], ip[1], ip[2], ip[3], payload);
+				
+				// send message to client
+				webSocket.sendTXT(num, "Connected");
             }
             break;
         case WStype_TEXT:
             USE_SERIAL.printf("[%u] get Text: %s\n", num, payload);
 
-            // echo data back to browser
-            webSocket.sendTXT(num, payload, lenght);
+            // send message to client
+            // webSocket.sendTXT(num, "message here");
 
             // send data to all connected clients
-            webSocket.broadcastTXT(payload, lenght);
+            // webSocket.broadcastTXT("message here");
             break;
         case WStype_BIN:
-            USE_SERIAL.printf("[%u] get binary lenght: %u\n", num, lenght);
-            hexdump(payload, lenght);
+            USE_SERIAL.printf("[%u] get binary length: %u\n", num, length);
+            hexdump(payload, length);
 
-            // echo data back to browser
-            webSocket.sendBIN(num, payload, lenght);
+            // send message to client
+            // webSocket.sendBIN(num, payload, length);
             break;
     }
 

examples/esp8266_pico/WebSocketServerAllFunctionsDemo/WebSocketServerAllFunctionsDemo.ino

@@ -0,0 +1,132 @@
+/*
+ * WebSocketServerAllFunctionsDemo.ino
+ *
+ *  Created on: 10.05.2018
+ *
+ */
+
+#include <Arduino.h>
+
+#include <ESP8266WiFi.h>
+#include <ESP8266WiFiMulti.h>
+#include <WebSocketsServer.h>
+#include <ESP8266WebServer.h>
+#include <ESP8266mDNS.h>
+#include <Hash.h>
+
+#define LED_RED     15
+#define LED_GREEN   12
+#define LED_BLUE    13
+
+#define USE_SERIAL Serial
+
+ESP8266WiFiMulti WiFiMulti;
+
+ESP8266WebServer server(80);
+WebSocketsServer webSocket = WebSocketsServer(81);
+
+void webSocketEvent(uint8_t num, WStype_t type, uint8_t * payload, size_t length) {
+
+    switch(type) {
+        case WStype_DISCONNECTED:
+            USE_SERIAL.printf("[%u] Disconnected!\n", num);
+            break;
+        case WStype_CONNECTED: {
+            IPAddress ip = webSocket.remoteIP(num);
+            USE_SERIAL.printf("[%u] Connected from %d.%d.%d.%d url: %s\n", num, ip[0], ip[1], ip[2], ip[3], payload);
+
+            // send message to client
+            webSocket.sendTXT(num, "Connected");
+        }
+            break;
+        case WStype_TEXT:
+            USE_SERIAL.printf("[%u] get Text: %s\n", num, payload);
+
+            if(payload[0] == '#') {
+                // we get RGB data
+
+                // decode rgb data
+                uint32_t rgb = (uint32_t) strtol((const char *) &payload[1], NULL, 16);
+
+                analogWrite(LED_RED, ((rgb >> 16) & 0xFF));
+                analogWrite(LED_GREEN, ((rgb >> 8) & 0xFF));
+                analogWrite(LED_BLUE, ((rgb >> 0) & 0xFF));
+            }
+
+            break;
+    }
+
+}
+
+void setup() {
+    //USE_SERIAL.begin(921600);
+    USE_SERIAL.begin(115200);
+
+    //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);
+    }
+
+    pinMode(LED_RED, OUTPUT);
+    pinMode(LED_GREEN, OUTPUT);
+    pinMode(LED_BLUE, OUTPUT);
+
+    digitalWrite(LED_RED, 1);
+    digitalWrite(LED_GREEN, 1);
+    digitalWrite(LED_BLUE, 1);
+
+    WiFiMulti.addAP("SSID", "passpasspass");
+
+    while(WiFiMulti.run() != WL_CONNECTED) {
+        delay(100);
+    }
+
+    // start webSocket server
+    webSocket.begin();
+    webSocket.onEvent(webSocketEvent);
+
+    if(MDNS.begin("esp8266")) {
+        USE_SERIAL.println("MDNS responder started");
+    }
+
+    // handle index
+    server.on("/", []() {
+        // send index.html
+        server.send(200, "text/html", "<html><head><script>var connection = new WebSocket('ws://'+location.hostname+':81/', ['arduino']);connection.onopen = function () {  connection.send('Connect ' + new Date()); }; connection.onerror = function (error) {    console.log('WebSocket Error ', error);};connection.onmessage = function (e) {  console.log('Server: ', e.data);};function sendRGB() {  var r = parseInt(document.getElementById('r').value).toString(16);  var g = parseInt(document.getElementById('g').value).toString(16);  var b = parseInt(document.getElementById('b').value).toString(16);  if(r.length < 2) { r = '0' + r; }   if(g.length < 2) { g = '0' + g; }   if(b.length < 2) { b = '0' + b; }   var rgb = '#'+r+g+b;    console.log('RGB: ' + rgb); connection.send(rgb); }</script></head><body>LED Control:<br/><br/>R: <input id=\"r\" type=\"range\" min=\"0\" max=\"255\" step=\"1\" oninput=\"sendRGB();\" /><br/>G: <input id=\"g\" type=\"range\" min=\"0\" max=\"255\" step=\"1\" oninput=\"sendRGB();\" /><br/>B: <input id=\"b\" type=\"range\" min=\"0\" max=\"255\" step=\"1\" oninput=\"sendRGB();\" /><br/></body></html>");
+    });
+
+    server.begin();
+
+    // Add service to MDNS
+    MDNS.addService("http", "tcp", 80);
+    MDNS.addService("ws", "tcp", 81);
+
+    digitalWrite(LED_RED, 0);
+    digitalWrite(LED_GREEN, 0);
+    digitalWrite(LED_BLUE, 0);
+
+}
+
+unsigned long last_10sec = 0;
+unsigned int counter = 0;
+
+void loop() {
+    unsigned long t = millis();
+    webSocket.loop();
+    server.handleClient();
+
+    if((t - last_10sec) > 10 * 1000) {
+        counter++;
+        bool ping = (counter % 2);
+        int i = webSocket.connectedClients(ping);
+        USE_SERIAL.printf("%d Connected websocket clients ping: %d\n", i, ping);
+        last_10sec = millis();
+    }
+}

examples/esp8266_pico/WebSocketServerFragmentation/WebSocketServerFragmentation.ino

@@ -0,0 +1,94 @@
+/*
+ * WebSocketServer.ino
+ *
+ *  Created on: 22.05.2015
+ *
+ */
+
+#include <Arduino.h>
+
+#include <ESP8266WiFi.h>
+#include <ESP8266WiFiMulti.h>
+#include <WebSocketsServer.h>
+#include <Hash.h>
+
+ESP8266WiFiMulti WiFiMulti;
+
+WebSocketsServer webSocket = WebSocketsServer(81);
+
+#define USE_SERIAL Serial
+
+String fragmentBuffer = "";
+
+void webSocketEvent(uint8_t num, WStype_t type, uint8_t * payload, size_t length) {
+
+	switch(type) {
+		case WStype_DISCONNECTED:
+			USE_SERIAL.printf("[%u] Disconnected!\n", num);
+			break;
+		case WStype_CONNECTED: {
+			IPAddress ip = webSocket.remoteIP(num);
+			USE_SERIAL.printf("[%u] Connected from %d.%d.%d.%d url: %s\n", num, ip[0], ip[1], ip[2], ip[3], payload);
+
+			// send message to client
+			webSocket.sendTXT(num, "Connected");
+		}
+			break;
+		case WStype_TEXT:
+			USE_SERIAL.printf("[%u] get Text: %s\n", num, payload);
+			break;
+		case WStype_BIN:
+			USE_SERIAL.printf("[%u] get binary length: %u\n", num, length);
+			hexdump(payload, length);
+			break;
+
+		// Fragmentation / continuation opcode handling
+		// case WStype_FRAGMENT_BIN_START:
+		case WStype_FRAGMENT_TEXT_START:
+			fragmentBuffer = (char*)payload;
+			USE_SERIAL.printf("[%u] get start start of Textfragment: %s\n", num, payload);
+			break;
+		case WStype_FRAGMENT:
+			fragmentBuffer += (char*)payload;
+			USE_SERIAL.printf("[%u] get Textfragment : %s\n", num, payload);
+			break;
+		case WStype_FRAGMENT_FIN:
+			fragmentBuffer += (char*)payload;
+			USE_SERIAL.printf("[%u] get end of Textfragment: %s\n", num, payload);
+			USE_SERIAL.printf("[%u] full frame: %s\n", num, fragmentBuffer.c_str());
+			break;
+	}
+
+}
+
+void setup() {
+	// USE_SERIAL.begin(921600);
+	USE_SERIAL.begin(115200);
+
+	//Serial.setDebugOutput(true);
+	USE_SERIAL.setDebugOutput(true);
+
+	USE_SERIAL.println();
+	USE_SERIAL.println();
+	USE_SERIAL.println();
+
+	for(uint8_t t = 4; t > 0; t--) {
+		USE_SERIAL.printf("[SETUP] BOOT WAIT %d...\n", t);
+		USE_SERIAL.flush();
+		delay(1000);
+	}
+
+	WiFiMulti.addAP("SSID", "passpasspass");
+
+	while(WiFiMulti.run() != WL_CONNECTED) {
+		delay(100);
+	}
+
+	webSocket.begin();
+	webSocket.onEvent(webSocketEvent);
+}
+
+void loop() {
+	webSocket.loop();
+}
+

examples/esp8266_pico/WebSocketServerHooked/WebSocketServerHooked.ino

@@ -0,0 +1,103 @@
+/*
+ * WebSocketServerHooked.ino
+ *
+ *  Created on: 22.05.2015
+ *  Hooked on:  28.10.2020
+ *
+ */
+
+#include <Arduino.h>
+
+#include <ESP8266WiFi.h>
+#include <ESP8266WiFiMulti.h>
+#include <WebSockets4WebServer.h>
+#include <Hash.h>
+#include <ESP8266mDNS.h>
+
+ESP8266WiFiMulti WiFiMulti;
+
+ESP8266WebServer server(80);
+WebSockets4WebServer webSocket;
+
+#define USE_SERIAL Serial
+
+void webSocketEvent(uint8_t num, WStype_t type, uint8_t * payload, size_t length) {
+
+    switch(type) {
+        case WStype_DISCONNECTED:
+            USE_SERIAL.printf("[%u] Disconnected!\n", num);
+            break;
+        case WStype_CONNECTED:
+            {
+                IPAddress ip = webSocket.remoteIP(num);
+                USE_SERIAL.printf("[%u] Connected from %d.%d.%d.%d url: %s\n", num, ip[0], ip[1], ip[2], ip[3], payload);
+
+				// send message to client
+				webSocket.sendTXT(num, "Connected");
+            }
+            break;
+        case WStype_TEXT:
+            USE_SERIAL.printf("[%u] get Text: %s\n", num, payload);
+
+            // send message to client
+            // webSocket.sendTXT(num, "message here");
+
+            // send data to all connected clients
+            // webSocket.broadcastTXT("message here");
+            break;
+        case WStype_BIN:
+            USE_SERIAL.printf("[%u] get binary length: %u\n", num, length);
+            hexdump(payload, length);
+
+            // send message to client
+            // webSocket.sendBIN(num, 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);
+    }
+
+    WiFiMulti.addAP("SSID", "passpasspass");
+
+    while(WiFiMulti.run() != WL_CONNECTED) {
+        delay(100);
+    }
+
+    server.on("/", []() {
+        server.send(200, "text/plain", "I am a regular webserver on port 80!\r\n");
+        server.send(200, "text/plain", "I am also a websocket server on '/ws' on the same port 80\r\n");
+    });
+
+    server.addHook(webSocket.hookForWebserver("/ws", webSocketEvent));
+
+    server.begin();
+    Serial.println("HTTP server started on port 80");
+    Serial.println("WebSocket server started on the same port");
+    Serial.printf("my network address is either 'arduinoWebsockets.local' (mDNS) or '%s'\n", WiFi.localIP().toString().c_str());
+
+    if (!MDNS.begin("arduinoWebsockets")) {
+        Serial.println("Error setting up MDNS responder!");
+    }
+}
+
+void loop() {
+    server.handleClient();
+    webSocket.loop();
+    MDNS.update();
+}

examples/esp8266_pico/WebSocketServerHooked/emu

@@ -0,0 +1,20 @@
+#!/bin/sh
+
+# linux script to compile&run arduinoWebSockets in a mock environment
+
+if [ -z "$ESP8266ARDUINO" ]; then
+    echo "please set ESP8266ARDUINO env-var to where esp8266/arduino sits"
+    exit 1
+fi
+
+set -e
+
+where=$(pwd)
+
+cd $ESP8266ARDUINO/tests/host/
+
+make -j FORCE32=0 \
+    ULIBDIRS=../../libraries/Hash/:~/dev/proj/arduino/libraries/arduinoWebSockets \
+    ${where}/WebSocketServerHooked
+
+valgrind ./bin/WebSocketServerHooked/WebSocketServerHooked -b "$@"

examples/esp8266_pico/WebSocketServerHooked/ws-testclient.py

@@ -0,0 +1,45 @@
+#!/usr/bin/env python3
+
+# python websocket client to test with
+# emulator: server is at ws://127.0.0.1:9080/ws
+# esp8266:  server is at ws:///ws
+# (uncomment the right line below)
+
+#uri = "ws://127.0.0.1:9080/ws"
+uri = "ws://arduinoWebsockets.local/ws"
+
+import websocket
+try:
+    import thread
+except ImportError:
+    import _thread as thread
+import time
+
+def on_message(ws, message):
+    print("message");
+    print(message)
+
+def on_error(ws, error):
+    print("error")
+    print(error)
+
+def on_close(ws):
+    print("### closed ###")
+
+def on_open(ws):
+    print("opened")
+    def run(*args):
+        for i in range(3):
+            time.sleep(1)
+            ws.send("Hello %d" % i)
+        time.sleep(1)
+        ws.close()
+        print("thread terminating...")
+    thread.start_new_thread(run, ())
+
+
+if __name__ == "__main__":
+    websocket.enableTrace(True)
+    ws = websocket.WebSocketApp(uri, on_message = on_message, on_error = on_error, on_close = on_close)
+    ws.on_open = on_open
+    ws.run_forever()

examples/esp8266_pico/WebSocketServerHttpHeaderValidation/WebSocketServerHttpHeaderValidation.ino

@@ -0,0 +1,86 @@
+/*
+ * WebSocketServerHttpHeaderValidation.ino
+ *
+ *  Created on: 08.06.2016
+ *
+ */
+
+#include <Arduino.h>
+
+#include <ESP8266WiFi.h>
+#include <ESP8266WiFiMulti.h>
+#include <WebSocketsServer.h>
+#include <Hash.h>
+
+ESP8266WiFiMulti WiFiMulti;
+
+WebSocketsServer webSocket = WebSocketsServer(81);
+
+#define USE_SERIAL Serial1
+
+const unsigned long int validSessionId = 12345; //some arbitrary value to act as a valid sessionId
+
+/*
+ * Returns a bool value as an indicator to describe whether a user is allowed to initiate a websocket upgrade
+ * based on the value of a cookie. This function expects the rawCookieHeaderValue to look like this "sessionId=<someSessionIdNumberValue>|"
+ */
+bool isCookieValid(String rawCookieHeaderValue) {
+
+	if (rawCookieHeaderValue.indexOf("sessionId") != -1) {
+		String sessionIdStr = rawCookieHeaderValue.substring(rawCookieHeaderValue.indexOf("sessionId=") + 10, rawCookieHeaderValue.indexOf("|"));
+		unsigned long int sessionId = strtoul(sessionIdStr.c_str(), NULL, 10);
+		return sessionId == validSessionId;
+	}
+	return false;
+}
+
+/*
+ * The WebSocketServerHttpHeaderValFunc delegate passed to webSocket.onValidateHttpHeader
+ */
+bool validateHttpHeader(String headerName, String headerValue) {
+
+	//assume a true response for any headers not handled by this validator
+	bool valid = true;
+
+	if(headerName.equalsIgnoreCase("Cookie")) {
+		//if the header passed is the Cookie header, validate it according to the rules in 'isCookieValid' function
+		valid = isCookieValid(headerValue);
+	}
+
+	return valid;
+}
+
+void setup() {
+    // USE_SERIAL.begin(921600);
+    USE_SERIAL.begin(115200);
+
+    //Serial.setDebugOutput(true);
+    USE_SERIAL.setDebugOutput(true);
+
+    USE_SERIAL.println();
+    USE_SERIAL.println();
+    USE_SERIAL.println();
+
+    for(uint8_t t = 4; t > 0; t--) {
+        USE_SERIAL.printf("[SETUP] BOOT WAIT %d...\n", t);
+        USE_SERIAL.flush();
+        delay(1000);
+    }
+
+    WiFiMulti.addAP("SSID", "passpasspass");
+
+    while(WiFiMulti.run() != WL_CONNECTED) {
+        delay(100);
+    }
+
+    //connecting clients must supply a valid session cookie at websocket upgrade handshake negotiation time
+    const char * headerkeys[] = { "Cookie" };
+    size_t headerKeyCount = sizeof(headerkeys) / sizeof(char*);
+    webSocket.onValidateHttpHeader(validateHttpHeader, headerkeys, headerKeyCount);
+    webSocket.begin();
+}
+
+void loop() {
+    webSocket.loop();
+}
+

examples/esp8266_pico/WebSocketServer_LEDcontrol/WebSocketServer_LEDcontrol.ino

@@ -0,0 +1,121 @@
+/*
+ * WebSocketServer_LEDcontrol.ino
+ *
+ *  Created on: 26.11.2015
+ *
+ */
+
+#include <Arduino.h>
+
+#include <ESP8266WiFi.h>
+#include <ESP8266WiFiMulti.h>
+#include <WebSocketsServer.h>
+#include <ESP8266WebServer.h>
+#include <ESP8266mDNS.h>
+#include <Hash.h>
+
+#define LED_RED     15
+#define LED_GREEN   12
+#define LED_BLUE    13
+
+#define USE_SERIAL Serial
+
+
+ESP8266WiFiMulti WiFiMulti;
+
+ESP8266WebServer server(80);
+WebSocketsServer webSocket = WebSocketsServer(81);
+
+void webSocketEvent(uint8_t num, WStype_t type, uint8_t * payload, size_t length) {
+
+    switch(type) {
+        case WStype_DISCONNECTED:
+            USE_SERIAL.printf("[%u] Disconnected!\n", num);
+            break;
+        case WStype_CONNECTED: {
+            IPAddress ip = webSocket.remoteIP(num);
+            USE_SERIAL.printf("[%u] Connected from %d.%d.%d.%d url: %s\n", num, ip[0], ip[1], ip[2], ip[3], payload);
+
+            // send message to client
+            webSocket.sendTXT(num, "Connected");
+        }
+            break;
+        case WStype_TEXT:
+            USE_SERIAL.printf("[%u] get Text: %s\n", num, payload);
+
+            if(payload[0] == '#') {
+                // we get RGB data
+
+                // decode rgb data
+                uint32_t rgb = (uint32_t) strtol((const char *) &payload[1], NULL, 16);
+
+                analogWrite(LED_RED,    ((rgb >> 16) & 0xFF));
+                analogWrite(LED_GREEN,  ((rgb >> 8) & 0xFF));
+                analogWrite(LED_BLUE,   ((rgb >> 0) & 0xFF));
+            }
+
+            break;
+    }
+
+}
+
+void setup() {
+    //USE_SERIAL.begin(921600);
+    USE_SERIAL.begin(115200);
+
+    //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);
+    }
+
+    pinMode(LED_RED, OUTPUT);
+    pinMode(LED_GREEN, OUTPUT);
+    pinMode(LED_BLUE, OUTPUT);
+
+    digitalWrite(LED_RED, 1);
+    digitalWrite(LED_GREEN, 1);
+    digitalWrite(LED_BLUE, 1);
+
+    WiFiMulti.addAP("SSID", "passpasspass");
+
+    while(WiFiMulti.run() != WL_CONNECTED) {
+        delay(100);
+    }
+
+    // start webSocket server
+    webSocket.begin();
+    webSocket.onEvent(webSocketEvent);
+
+    if(MDNS.begin("esp8266")) {
+        USE_SERIAL.println("MDNS responder started");
+    }
+
+    // handle index
+    server.on("/", []() {
+        // send index.html
+        server.send(200, "text/html", "<html><head><script>var connection = new WebSocket('ws://'+location.hostname+':81/', ['arduino']);connection.onopen = function () {  connection.send('Connect ' + new Date()); }; connection.onerror = function (error) {    console.log('WebSocket Error ', error);};connection.onmessage = function (e) {  console.log('Server: ', e.data);};function sendRGB() {  var r = parseInt(document.getElementById('r').value).toString(16);  var g = parseInt(document.getElementById('g').value).toString(16);  var b = parseInt(document.getElementById('b').value).toString(16);  if(r.length < 2) { r = '0' + r; }   if(g.length < 2) { g = '0' + g; }   if(b.length < 2) { b = '0' + b; }   var rgb = '#'+r+g+b;    console.log('RGB: ' + rgb); connection.send(rgb); }</script></head><body>LED Control:<br/><br/>R: <input id=\"r\" type=\"range\" min=\"0\" max=\"255\" step=\"1\" oninput=\"sendRGB();\" /><br/>G: <input id=\"g\" type=\"range\" min=\"0\" max=\"255\" step=\"1\" oninput=\"sendRGB();\" /><br/>B: <input id=\"b\" type=\"range\" min=\"0\" max=\"255\" step=\"1\" oninput=\"sendRGB();\" /><br/></body></html>");
+    });
+
+    server.begin();
+
+    // Add service to MDNS
+    MDNS.addService("http", "tcp", 80);
+    MDNS.addService("ws", "tcp", 81);
+
+    digitalWrite(LED_RED, 0);
+    digitalWrite(LED_GREEN, 0);
+    digitalWrite(LED_BLUE, 0);
+
+}
+
+void loop() {
+    webSocket.loop();
+    server.handleClient();
+}

examples/particle/ParticleWebSocketClient/application.cpp

@@ -0,0 +1,46 @@
+/* To compile using make CLI, create a folder under \firmware\user\applications and copy application.cpp there.
+*  Then, copy src files under particleWebSocket folder.
+*/
+
+#include "application.h"
+#include "particleWebSocket/WebSocketsClient.h"
+
+WebSocketsClient webSocket;
+
+void webSocketEvent(WStype_t type, uint8_t* payload, size_t length)
+{
+	switch (type)
+	{
+	case WStype_DISCONNECTED:
+		Serial.printlnf("[WSc] Disconnected!");
+		break;
+	case WStype_CONNECTED:
+		Serial.printlnf("[WSc] Connected to URL: %s", payload);
+		webSocket.sendTXT("Connected\r\n");
+		break;
+	case WStype_TEXT:
+		Serial.printlnf("[WSc] get text: %s", payload);
+		break;
+	case WStype_BIN:
+		Serial.printlnf("[WSc] get binary length: %u", length);
+		break;
+	}
+}
+
+void setup()
+{
+	Serial.begin(9600);
+	
+	WiFi.setCredentials("[SSID]", "[PASSWORD]", WPA2, WLAN_CIPHER_AES_TKIP);
+	WiFi.connect();
+	    
+	webSocket.begin("192.168.1.153", 85, "/ClientService/?variable=Test1212");
+	webSocket.onEvent(webSocketEvent);
+}
+
+void loop()
+{
+	webSocket.sendTXT("Hello world!");
+	delay(500);
+	webSocket.loop();
+}

examples/seeed-studio/xio-wio-terminal/WebSocketClient/WebSocketClient.ino

@@ -0,0 +1,105 @@
+/*
+ * WebSocketClient.ino
+ *
+ *  Created on: 10.08.2024
+ *
+ */
+
+#include <Arduino.h>
+#include <rpcWiFi.h>
+#include <WiFiMulti.h>
+#include <WebSocketsClient.h>
+
+WebSocketsClient webSocket;
+WiFiMulti wifiMulti;
+
+#define USE_SERIAL Serial
+
+void hexdump(const void *mem, uint32_t len, uint8_t cols = 16) {
+	const uint8_t* src = (const uint8_t*) mem;
+	USE_SERIAL.printf("\n[HEXDUMP] Address: 0x%08X len: 0x%X (%d)", (ptrdiff_t)src, len, len);
+	for(uint32_t i = 0; i < len; i++) {
+		if(i % cols == 0) {
+			USE_SERIAL.printf("\n[0x%08X] 0x%08X: ", (ptrdiff_t)src, i);
+		}
+		USE_SERIAL.printf("%02X ", *src);
+		src++;
+	}
+	USE_SERIAL.printf("\n");
+}
+
+void webSocketEvent(WStype_t type, uint8_t * payload, size_t length) {
+
+	switch(type) {
+		case WStype_DISCONNECTED:
+			USE_SERIAL.printf("[WSc] Disconnected!\n");
+			break;
+		case WStype_CONNECTED:
+			USE_SERIAL.printf("[WSc] Connected to url: %s\n", payload);
+
+			// send message to server when Connected
+			webSocket.sendTXT("Connected");
+			break;
+		case WStype_TEXT:
+			USE_SERIAL.printf("[WSc] get text: %s\n", payload);
+
+			// send message to server
+			// webSocket.sendTXT("message here");
+			break;
+		case WStype_BIN:
+			USE_SERIAL.printf("[WSc] get binary length: %u\n", length);
+			hexdump(payload, length);
+
+			// send data to server
+			// webSocket.sendBIN(payload, length);
+			break;
+		case WStype_ERROR:			
+		case WStype_FRAGMENT_TEXT_START:
+		case WStype_FRAGMENT_BIN_START:
+		case WStype_FRAGMENT:
+    case WStype_PONG:
+    case WStype_PING:
+		case WStype_FRAGMENT_FIN:
+			break;
+	}
+
+}
+
+void setup() {
+	// USE_SERIAL.begin(921600);
+	USE_SERIAL.begin(115200);
+	
+	USE_SERIAL.println();
+	USE_SERIAL.println();
+	USE_SERIAL.println();
+
+	for(uint8_t t = 4; t > 0; t--) {
+		USE_SERIAL.printf("[SETUP] BOOT WAIT %d...\n", t);
+		USE_SERIAL.flush();
+		delay(1000);
+	}
+
+	wifiMulti.addAP("SSID", "passpasspass");
+
+	//WiFi.disconnect();
+	while(wifiMulti.run() != WL_CONNECTED) {
+		delay(100);
+	}
+
+	// server address, port and URL
+	webSocket.begin("192.168.0.123", 81, "/");
+
+	// event handler
+	webSocket.onEvent(webSocketEvent);
+
+	// use HTTP Basic Authorization this is optional remove if not needed
+	webSocket.setAuthorization("user", "Password");
+
+	// try ever 5000 again if connection has failed
+	webSocket.setReconnectInterval(5000);
+
+}
+
+void loop() {
+	webSocket.loop();
+}

library.json

@@ -0,0 +1,25 @@
+{
+    "authors": [
+        {
+            "maintainer": true,
+            "name": "Markus Sattler",
+            "url": "https://github.com/Links2004"
+        }
+    ],
+    "description": "WebSocket Server and Client for Arduino based on RFC6455",
+    "export": {
+        "exclude": [
+            "tests"
+        ]
+    },
+    "frameworks": "arduino",
+    "keywords": "wifi, http, web, server, client, websocket",
+    "license": "LGPL-2.1",
+    "name": "WebSockets",
+    "platforms": "*",
+    "repository": {
+        "type": "git",
+        "url": "https://github.com/Links2004/arduinoWebSockets.git"
+    },
+    "version": "2.6.1"
+}

library.properties

@@ -1,8 +1,9 @@
 name=WebSockets
-version=1.1
+version=2.6.1
 author=Markus Sattler
-maintainer=Markus Sattler 
+maintainer=Markus Sattler
 sentence=WebSockets for Arduino (Server + Client)
-paragraph=
+paragraph=use 2.x.x for ESP and 1.3 for AVR
+category=Communication
 url=https://github.com/Links2004/arduinoWebSockets
 architectures=*

src/SocketIOclient.cpp

@@ -0,0 +1,264 @@
+/*
+ * 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, uint32_t pingInterval, uint32_t pongTimeout, uint8_t disconnectTimeoutCount) {
+    WebSocketsClient::beginSocketIO(host, port, url, protocol);
+    WebSocketsClient::enableHeartbeat(pingInterval, pongTimeout, disconnectTimeoutCount);
+    initClient();
+}
+
+void SocketIOclient::begin(String host, uint16_t port, String url, String protocol, uint32_t pingInterval, uint32_t pongTimeout, uint8_t disconnectTimeoutCount) {
+    WebSocketsClient::beginSocketIO(host, port, url, protocol);
+    WebSocketsClient::enableHeartbeat(pingInterval, pongTimeout, disconnectTimeoutCount);
+    initClient();
+}
+#if defined(HAS_SSL)
+void SocketIOclient::beginSSL(const char * host, uint16_t port, const char * url, const char * protocol, uint32_t pingInterval, uint32_t pongTimeout, uint8_t disconnectTimeoutCount) {
+    WebSocketsClient::beginSocketIOSSL(host, port, url, protocol);
+    WebSocketsClient::enableHeartbeat(pingInterval, pongTimeout, disconnectTimeoutCount);
+    initClient();
+}
+
+void SocketIOclient::beginSSL(String host, uint16_t port, String url, String protocol, uint32_t pingInterval, uint32_t pongTimeout, uint8_t disconnectTimeoutCount) {
+    WebSocketsClient::beginSocketIOSSL(host, port, url, protocol);
+    WebSocketsClient::enableHeartbeat(pingInterval, pongTimeout, disconnectTimeoutCount);
+    initClient();
+}
+#if defined(SSL_BARESSL)
+void SocketIOclient::beginSSLWithCA(const char * host, uint16_t port, const char * url, const char * CA_cert, const char * protocol, uint32_t pingInterval, uint32_t pongTimeout, uint8_t disconnectTimeoutCount) {
+    WebSocketsClient::beginSocketIOSSLWithCA(host, port, url, CA_cert, protocol);
+    WebSocketsClient::enableHeartbeat(pingInterval, pongTimeout, disconnectTimeoutCount);
+    initClient();
+}
+
+void SocketIOclient::beginSSLWithCA(const char * host, uint16_t port, const char * url, BearSSL::X509List * CA_cert, const char * protocol, uint32_t pingInterval, uint32_t pongTimeout, uint8_t disconnectTimeoutCount) {
+    WebSocketsClient::beginSocketIOSSLWithCA(host, port, url, CA_cert, protocol);
+    WebSocketsClient::enableHeartbeat(pingInterval, pongTimeout, disconnectTimeoutCount);
+    initClient();
+}
+
+void SocketIOclient::setSSLClientCertKey(const char * clientCert, const char * clientPrivateKey) {
+    WebSocketsClient::setSSLClientCertKey(clientCert, clientPrivateKey);
+}
+
+void SocketIOclient::setSSLClientCertKey(BearSSL::X509List * clientCert, BearSSL::PrivateKey * clientPrivateKey) {
+    WebSocketsClient::setSSLClientCertKey(clientCert, clientPrivateKey);
+}
+
+#endif
+#endif
+
+void SocketIOclient::configureEIOping(bool disableHeartbeat) {
+    _disableHeartbeat = disableHeartbeat;
+}
+
+void SocketIOclient::initClient(void) {
+    if(_client.cUrl.indexOf("EIO=4") != -1) {
+        DEBUG_WEBSOCKETS("[wsIOc] found EIO=4 disable EIO ping on client\n");
+        configureEIOping(true);
+    }
+}
+
+/**
+ * set callback function
+ * @param cbEvent SocketIOclientEvent
+ */
+void SocketIOclient::onEvent(SocketIOclientEvent cbEvent) {
+    _cbEvent = cbEvent;
+}
+
+bool SocketIOclient::isConnected(void) {
+    return WebSocketsClient::isConnected();
+}
+
+void SocketIOclient::setExtraHeaders(const char * extraHeaders) {
+    return WebSocketsClient::setExtraHeaders(extraHeaders);
+}
+
+void SocketIOclient::setReconnectInterval(unsigned long time) {
+    return WebSocketsClient::setReconnectInterval(time);
+}
+
+void SocketIOclient::disconnect(void) {
+    WebSocketsClient::disconnect();
+}
+
+/**
+ * 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) && _client.status == WSC_CONNECTED) {
+        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(!_disableHeartbeat && (t - _lastHeartbeat) > EIO_HEARTBEAT_INTERVAL) {
+        _lastHeartbeat = 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("2probe");
+            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:
+                            DEBUG_WEBSOCKETS("[wsIOc] connected (%d): %s\n", lData, data);
+                            return;
+                        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,108 @@
+/**
+ * SocketIOclient.h
+ *
+ *  Created on: May 12, 2018
+ *      Author: links
+ */
+
+#ifndef SOCKETIOCLIENT_H_
+#define SOCKETIOCLIENT_H_
+
+#include "WebSockets.h"
+#include "WebSocketsClient.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", uint32_t pingInterval = 60 * 1000, uint32_t pongTimeout = 90 * 1000, uint8_t disconnectTimeoutCount = 5);
+    void begin(String host, uint16_t port, String url = "/socket.io/?EIO=3", String protocol = "arduino", uint32_t pingInterval = 60 * 1000, uint32_t pongTimeout = 90 * 1000, uint8_t disconnectTimeoutCount = 5);
+
+#ifdef HAS_SSL
+    void beginSSL(const char * host, uint16_t port, const char * url = "/socket.io/?EIO=3", const char * protocol = "arduino", uint32_t pingInterval = 60 * 1000, uint32_t pongTimeout = 90 * 1000, uint8_t disconnectTimeoutCount = 5);
+    void beginSSL(String host, uint16_t port, String url = "/socket.io/?EIO=3", String protocol = "arduino", uint32_t pingInterval = 60 * 1000, uint32_t pongTimeout = 90 * 1000, uint8_t disconnectTimeoutCount = 5);
+#ifndef SSL_AXTLS
+    void beginSSLWithCA(const char * host, uint16_t port, const char * url = "/socket.io/?EIO=3", const char * CA_cert = NULL, const char * protocol = "arduino", uint32_t pingInterval = 60 * 1000, uint32_t pongTimeout = 90 * 1000, uint8_t disconnectTimeoutCount = 5);
+    void setSSLClientCertKey(const char * clientCert = NULL, const char * clientPrivateKey = NULL);
+#if defined(SSL_BARESSL)
+    void beginSSLWithCA(const char * host, uint16_t port, const char * url = "/socket.io/?EIO=3", BearSSL::X509List * CA_cert = NULL, const char * protocol = "arduino", uint32_t pingInterval = 60 * 1000, uint32_t pongTimeout = 90 * 1000, uint8_t disconnectTimeoutCount = 5);
+    void setSSLClientCertKey(BearSSL::X509List * clientCert = NULL, BearSSL::PrivateKey * clientPrivateKey = NULL);
+#endif
+#endif
+#endif
+    bool isConnected(void);
+
+    void onEvent(SocketIOclientEvent cbEvent);
+    void disconnect(void);
+
+    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 setExtraHeaders(const char * extraHeaders = NULL);
+    void setReconnectInterval(unsigned long time);
+
+    void loop(void);
+
+    void configureEIOping(bool disableHeartbeat = false);
+
+  protected:
+    bool _disableHeartbeat  = false;
+    uint64_t _lastHeartbeat = 0;
+    SocketIOclientEvent _cbEvent;
+    virtual void runIOCbEvent(socketIOmessageType_t type, uint8_t * payload, size_t length) {
+        if(_cbEvent) {
+            _cbEvent(type, payload, length);
+        }
+    }
+
+    void initClient(void);
+
+    // 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

@@ -24,26 +24,53 @@
 
 #include "WebSockets.h"
 
+#ifdef ESP8266
+#include <core_esp8266_features.h>
+#endif
+
 extern "C" {
-#include "libb64/cencode.h"
+#ifdef CORE_HAS_LIBB64
+#include <libb64/cencode.h>
+#else
+#include "libb64/cencode_inc.h"
+#endif
 }
 
 #ifdef ESP8266
 #include <Hash.h>
+#elif defined(ESP32)
+#include <esp_system.h>
+
+#if ESP_IDF_VERSION_MAJOR >= 4
+#if(ESP_ARDUINO_VERSION >= ESP_ARDUINO_VERSION_VAL(1, 0, 6))
+#include "sha/sha_parallel_engine.h"
+#else
+#include <esp32/sha.h>
+#endif
+#else
+#include <hwcrypto/sha.h>
+#endif
+
+#else
+
+extern "C" {
+#include "libsha1/libsha1.h"
+}
+
 #endif
 
 /**
  *
  * @param client WSclient_t *  ptr to the client struct
  * @param code uint16_t see RFC
- * @param reason
- * @param reasonLen
+ * @param reason ptr to the disconnect reason message
+ * @param reasonLen length of the disconnect reason message
  */
 void WebSockets::clientDisconnect(WSclient_t * client, uint16_t code, char * reason, size_t reasonLen) {
     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);
@@ -56,39 +83,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 *
- * @param length size_t
+ * @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!)
  */
-void WebSockets::sendFrame(WSclient_t * client, WSopcode_t opcode, uint8_t * payload, size_t length, bool mask, bool fin, bool headerToPayload) {
-
-    if(!client->tcp.connected()) {
-        DEBUG_WEBSOCKETS("[WS][%d][sendFrame] not Connected!?\n", client->num);
-        return;
-    }
-
-    if(client->status != WSC_CONNECTED) {
-        DEBUG_WEBSOCKETS("[WS][%d][sendFrame] not in WSC_CONNECTED state!?\n", client->num);
-        return;
-    }
-
-    DEBUG_WEBSOCKETS("[WS][%d][sendFrame] ------- send massage 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] = { 0 };
-    uint8_t buffer[14] = { 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;
-
     // calculate header Size
     if(length < 126) {
         headerSize = 2;
@@ -102,14 +105,6 @@ void WebSockets::sendFrame(WSclient_t * client, WSopcode_t opcode, uint8_t * pay
         headerSize += 4;
     }
 
-    // set Header Pointer
-    if(headerToPayload) {
-        // calculate offset in payload
-        headerPtr = (payload + (14 - headerSize));
-    } else {
-        headerPtr = &buffer[0];
-    }
-
     // create header
 
     // byte 0
@@ -117,7 +112,7 @@ void 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
@@ -127,52 +122,216 @@ void WebSockets::sendFrame(WSclient_t * client, WSopcode_t opcode, uint8_t * pay
     }
 
     if(length < 126) {
-        *headerPtr |= length;                   headerPtr++;
+        *headerPtr |= length;
+        headerPtr++;
     } else if(length < 0xFFFF) {
-        *headerPtr |= 126;                      headerPtr++;
-        *headerPtr = ((length >> 8) & 0xFF);    headerPtr++;
-        *headerPtr = (length & 0xFF);           headerPtr++;
+        *headerPtr |= 126;
+        headerPtr++;
+        *headerPtr = ((length >> 8) & 0xFF);
+        headerPtr++;
+        *headerPtr = (length & 0xFF);
+        headerPtr++;
     } else {
-        // normaly we never get here (to less memory)
-        *headerPtr |= 127;                      headerPtr++;
-        *headerPtr = 0x00;                      headerPtr++;
-        *headerPtr = 0x00;                      headerPtr++;
-        *headerPtr = 0x00;                      headerPtr++;
-        *headerPtr = 0x00;                      headerPtr++;
-        *headerPtr = ((length >> 24) & 0xFF);   headerPtr++;
-        *headerPtr = ((length >> 16) & 0xFF);   headerPtr++;
-        *headerPtr = ((length >> 8) & 0xFF);    headerPtr++;
-        *headerPtr = (length & 0xFF);           headerPtr++;
+        // Normally we never get here (to less memory)
+        *headerPtr |= 127;
+        headerPtr++;
+        *headerPtr = 0x00;
+        headerPtr++;
+        *headerPtr = 0x00;
+        headerPtr++;
+        *headerPtr = 0x00;
+        headerPtr++;
+        *headerPtr = 0x00;
+        headerPtr++;
+        *headerPtr = ((length >> 24) & 0xFF);
+        headerPtr++;
+        *headerPtr = ((length >> 16) & 0xFF);
+        headerPtr++;
+        *headerPtr = ((length >> 8) & 0xFF);
+        headerPtr++;
+        *headerPtr = (length & 0xFF);
+        headerPtr++;
     }
 
     if(mask) {
-        // todo generate random mask key
+        *headerPtr = maskKey[0];
+        headerPtr++;
+        *headerPtr = maskKey[1];
+        headerPtr++;
+        *headerPtr = maskKey[2];
+        headerPtr++;
+        *headerPtr = maskKey[3];
+        headerPtr++;
+    }
+    return headerSize;
+}
+
+/**
+ *
+ * @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 };
+
+    uint8_t headerSize = createHeader(&buffer[0], opcode, length, client->cIsClient, maskKey, fin);
+
+    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);
-            maskKey[x] = 0x00; // fake xor (0x00 0x00 0x00 0x00)
-            *headerPtr = maskKey[x];            headerPtr++;
+            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 {
+            dataMaskPtr = payloadPtr;
         }
 
-        // todo encode XOR (note: using payload not working for static content from flash)
-        //for(size_t x = 0; x < length; x++) {
-        //    payload[x] = (payload[x] ^ maskKey[x % 4]);
-        //}
+        for(size_t x = 0; x < length; x++) {
+            dataMaskPtr[x] = (dataMaskPtr[x] ^ maskKey[x % 4]);
+        }
     }
 
+#ifndef NODEBUG_WEBSOCKETS
+    unsigned long start = micros();
+#endif
+
     if(headerToPayload) {
         // header has be added to payload
         // payload is forced to reserved 14 Byte but we may not need all based on the length and mask settings
         // offset in payload is calculatetd 14 - headerSize
-        client->tcp.write(&payload[(14 - headerSize)], (length + headerSize));
+        if(write(client, &payloadPtr[(WEBSOCKETS_MAX_HEADER_SIZE - headerSize)], (length + headerSize)) != (length + headerSize)) {
+            ret = false;
+        }
     } else {
         // send header
-        client->tcp.write(&buffer[0], headerSize);
+        if(write(client, &buffer[0], headerSize) != headerSize) {
+            ret = false;
+        }
 
-        if(payload && length > 0) {
+        if(payloadPtr && length > 0) {
             // send payload
-            client->tcp.write(&payload[0], length);
+            if(write(client, &payloadPtr[0], length) != length) {
+                ret = false;
+            }
         }
     }
+
+    DEBUG_WEBSOCKETS("[WS][%d][sendFrame] sending Frame Done (%luus).\n", client->num, (micros() - start));
+
+#ifdef WEBSOCKETS_USE_BIG_MEM
+    if(useInternBuffer && payloadPtr) {
+        free(payloadPtr);
+    }
+#endif
+
+    return ret;
+}
+
+/**
+ * callen when HTTP header is done
+ * @param client WSclient_t *  ptr to the client struct
+ */
+void WebSockets::headerDone(WSclient_t * client) {
+    client->status    = WSC_CONNECTED;
+    client->cWsRXsize = 0;
+    DEBUG_WEBSOCKETS("[WS][%d][headerDone] Header Handling Done.\n", client->num);
+#if(WEBSOCKETS_NETWORK_TYPE == NETWORK_ESP8266_ASYNC)
+    client->cHttpLine = "";
+    handleWebsocket(client);
+#endif
 }
 
 /**
@@ -180,145 +339,202 @@ void WebSockets::sendFrame(WSclient_t * client, WSopcode_t opcode, uint8_t * pay
  * @param client WSclient_t *  ptr to the client struct
  */
 void WebSockets::handleWebsocket(WSclient_t * client) {
+    if(client->cWsRXsize == 0) {
+        handleWebsocketCb(client);
+    }
+}
 
-    uint8_t buffer[8] = { 0 };
+/**
+ * wait for
+ * @param client
+ * @param size
+ */
+bool WebSockets::handleWebsocketWaitFor(WSclient_t * client, size_t size) {
+    if(!client->tcp || !client->tcp->connected()) {
+        return false;
+    }
 
-    bool fin;
-    bool rsv1;
-    bool rsv2;
-    bool rsv3;
-    WSopcode_t opCode;
-    bool mask;
-    size_t payloadLen;
+    if(size > WEBSOCKETS_MAX_HEADER_SIZE) {
+        DEBUG_WEBSOCKETS("[WS][%d][handleWebsocketWaitFor] size: %d too big!\n", client->num, size);
+        return false;
+    }
 
-    uint8_t maskKey[4];
+    if(client->cWsRXsize >= size) {
+        return true;
+    }
 
-    uint8_t * payload = NULL;
+    DEBUG_WEBSOCKETS("[WS][%d][handleWebsocketWaitFor] size: %d cWsRXsize: %d\n", client->num, size, client->cWsRXsize);
+    readCb(client, &client->cWsHeader[client->cWsRXsize], (size - client->cWsRXsize), std::bind([](WebSockets * server, size_t size, WSclient_t * client, bool ok) {
+        DEBUG_WEBSOCKETS("[WS][%d][handleWebsocketWaitFor][readCb] size: %d ok: %d\n", client->num, size, ok);
+        if(ok) {
+            client->cWsRXsize = size;
+            server->handleWebsocketCb(client);
+        } else {
+            DEBUG_WEBSOCKETS("[WS][%d][readCb] failed.\n", client->num);
+            client->cWsRXsize = 0;
+            // timeout or error
+            server->clientDisconnect(client, 1002);
+        }
+    },
+                                                                                          this, size, std::placeholders::_1, std::placeholders::_2));
+    return false;
+}
 
-    DEBUG_WEBSOCKETS("[WS][%d][handleWebsocket] ------- read massage frame -------\n", client->num);
+void WebSockets::handleWebsocketCb(WSclient_t * client) {
+    if(!client->tcp || !client->tcp->connected()) {
+        return;
+    }
 
-    if(!readWait(client, buffer, 2)) {
-        //timeout
-        clientDisconnect(client, 1002);
+    uint8_t * buffer = client->cWsHeader;
+
+    WSMessageHeader_t * header = &client->cWsHeaderDecode;
+    uint8_t * payload          = NULL;
+
+    uint8_t headerLen = 2;
+
+    if(!handleWebsocketWaitFor(client, headerLen)) {
         return;
     }
 
     // split first 2 bytes in the data
-    fin = ((buffer[0] >> 7) & 0x01);
-    rsv1 = ((buffer[0] >> 6) & 0x01);
-    rsv2 = ((buffer[0] >> 5) & 0x01);
-    rsv3 = ((buffer[0] >> 4) & 0x01);
-    opCode = (WSopcode_t) (buffer[0] & 0x0F);
+    header->fin    = ((*buffer >> 7) & 0x01);
+    header->rsv1   = ((*buffer >> 6) & 0x01);
+    header->rsv2   = ((*buffer >> 5) & 0x01);
+    header->rsv3   = ((*buffer >> 4) & 0x01);
+    header->opCode = (WSopcode_t)(*buffer & 0x0F);
+    buffer++;
 
-    mask = ((buffer[1] >> 7) & 0x01);
-    payloadLen = (WSopcode_t) (buffer[1] & 0x7F);
+    header->mask       = ((*buffer >> 7) & 0x01);
+    header->payloadLen = (WSopcode_t)(*buffer & 0x7F);
+    buffer++;
 
-    if(payloadLen == 126) {
-        if(!readWait(client, buffer, 2)) {
-            //timeout
-            clientDisconnect(client, 1002);
+    if(header->payloadLen == 126) {
+        headerLen += 2;
+        if(!handleWebsocketWaitFor(client, headerLen)) {
             return;
         }
-        payloadLen = buffer[0] << 8 | buffer[1];
-    } else if(payloadLen == 127) {
-        // read 64bit inteager as length
-        if(!readWait(client, buffer, 8)) {
-            //timeout
-            clientDisconnect(client, 1002);
+        header->payloadLen = buffer[0] << 8 | buffer[1];
+        buffer += 2;
+    } else if(header->payloadLen == 127) {
+        headerLen += 8;
+        // read 64bit integer as length
+        if(!handleWebsocketWaitFor(client, headerLen)) {
             return;
         }
 
         if(buffer[0] != 0 || buffer[1] != 0 || buffer[2] != 0 || buffer[3] != 0) {
-            // really to big!
-            payloadLen = 0xFFFFFFFF;
+            // really too big!
+            header->payloadLen = 0xFFFFFFFF;
         } else {
-            payloadLen = buffer[4] << 24 | buffer[5] << 16 | buffer[6] << 8 | buffer[7];
+            header->payloadLen = buffer[4] << 24 | buffer[5] << 16 | buffer[6] << 8 | buffer[7];
         }
+        buffer += 8;
     }
 
-    DEBUG_WEBSOCKETS("[WS][%d][handleWebsocket] fin: %u rsv1: %u rsv2: %u rsv3 %u  opCode: %u\n", client->num, fin, rsv1, rsv2, rsv3, opCode);
-    DEBUG_WEBSOCKETS("[WS][%d][handleWebsocket] mask: %u payloadLen: %u\n", client->num, mask, payloadLen);
+    DEBUG_WEBSOCKETS("[WS][%d][handleWebsocket] ------- read massage frame -------\n", client->num);
+    DEBUG_WEBSOCKETS("[WS][%d][handleWebsocket] fin: %u rsv1: %u rsv2: %u rsv3 %u  opCode: %u\n", client->num, header->fin, header->rsv1, header->rsv2, header->rsv3, header->opCode);
+    DEBUG_WEBSOCKETS("[WS][%d][handleWebsocket] mask: %u payloadLen: %u\n", client->num, header->mask, header->payloadLen);
 
-    if(payloadLen > WEBSOCKETS_MAX_DATA_SIZE) {
-        DEBUG_WEBSOCKETS("[WS][%d][handleWebsocket] payload to big! (%u)\n", client->num, payloadLen);
+    if(header->payloadLen > WEBSOCKETS_MAX_DATA_SIZE) {
+        DEBUG_WEBSOCKETS("[WS][%d][handleWebsocket] payload too big! (%u)\n", client->num, header->payloadLen);
         clientDisconnect(client, 1009);
         return;
     }
 
-    if(mask) {
-        client->tcp.read(maskKey, 4);
+    if(header->mask) {
+        headerLen += 4;
+        if(!handleWebsocketWaitFor(client, headerLen)) {
+            return;
+        }
+        header->maskKey = buffer;
+        buffer += 4;
     }
 
-    if(payloadLen > 0) {
+    if(header->payloadLen > 0) {
         // if text data we need one more
-        payload = (uint8_t *) malloc(payloadLen + 1);
+        payload = (uint8_t *)malloc(header->payloadLen + 1);
 
         if(!payload) {
-            DEBUG_WEBSOCKETS("[WS][%d][handleWebsocket] to less memory to handle payload %d!\n", client->num, payloadLen);
+            DEBUG_WEBSOCKETS("[WS][%d][handleWebsocket] to less memory to handle payload %d!\n", client->num, header->payloadLen);
             clientDisconnect(client, 1011);
             return;
         }
+        readCb(client, payload, header->payloadLen, std::bind(&WebSockets::handleWebsocketPayloadCb, this, std::placeholders::_1, std::placeholders::_2, payload));
+    } else {
+        handleWebsocketPayloadCb(client, true, NULL);
+    }
+}
 
-        if(!readWait(client, payload, payloadLen)) {
-            DEBUG_WEBSOCKETS("[WS][%d][handleWebsocket] missing data!\n", client->num);
-            free(payload);
-            clientDisconnect(client, 1002);
-            return;
-        }
+void WebSockets::handleWebsocketPayloadCb(WSclient_t * client, bool ok, uint8_t * payload) {
+    WSMessageHeader_t * header = &client->cWsHeaderDecode;
+    if(ok) {
+        if(header->payloadLen > 0) {
+            payload[header->payloadLen] = 0x00;
 
-        payload[payloadLen] = 0x00;
-
-        if(mask) {
-            //decode XOR
-            for(size_t i = 0; i < payloadLen; i++) {
-                payload[i] = (payload[i] ^ maskKey[i % 4]);
+            if(header->mask) {
+                // decode XOR
+                for(size_t i = 0; i < header->payloadLen; i++) {
+                    payload[i] = (payload[i] ^ header->maskKey[i % 4]);
+                }
             }
         }
-    }
 
-    switch(opCode) {
-        case WSop_text:
-            DEBUG_WEBSOCKETS("[WS][%d][handleWebsocket] text: %s\n", client->num, payload);
-            // no break here!
-        case WSop_binary:
-            messageRecived(client, opCode, payload, payloadLen);
-            break;
-        case WSop_ping:
-            // send pong back
-            sendFrame(client, WSop_pong, payload, payloadLen);
-            break;
-        case WSop_pong:
-            DEBUG_WEBSOCKETS("[WS][%d][handleWebsocket] get pong  (%s)\n", client->num, payload);
-            break;
-        case WSop_close:
-            {
+        switch(header->opCode) {
+            case WSop_text:
+                DEBUG_WEBSOCKETS("[WS][%d][handleWebsocket] text: %s\n", client->num, payload);
+                // fallthrough
+            case WSop_binary:
+            case WSop_continuation:
+                messageReceived(client, header->opCode, payload, header->payloadLen, header->fin);
+                break;
+            case WSop_ping:
+                // send pong back
+                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 : "");
+                client->pongReceived = true;
+                messageReceived(client, header->opCode, payload, header->payloadLen, header->fin);
+                break;
+            case WSop_close: {
+#ifndef NODEBUG_WEBSOCKETS
                 uint16_t reasonCode = 1000;
-                if(payloadLen >= 2) {
+                if(header->payloadLen >= 2) {
                     reasonCode = payload[0] << 8 | payload[1];
                 }
-
-                DEBUG_WEBSOCKETS("[WS][%d][handleWebsocket] get ask for close. Code: %d", client->num, reasonCode);
-                if(payloadLen > 2) {
-                    DEBUG_WEBSOCKETS(" (%s)\n", (payload+2));
+#endif
+                DEBUG_WEBSOCKETS("[WS][%d][handleWebsocket] get ask for close. Code: %d\n", client->num, reasonCode);
+                if(header->payloadLen > 2) {
+                    DEBUG_WEBSOCKETS(" (%s)\n", (payload + 2));
                 } else {
                     DEBUG_WEBSOCKETS("\n");
                 }
                 clientDisconnect(client, 1000);
-            }
-            break;
-        case WSop_continuation:
-            // continuation is not supported
-            clientDisconnect(client, 1003);
-            break;
-        default:
-            clientDisconnect(client, 1002);
-            break;
-    }
+            } break;
+            default:
+                DEBUG_WEBSOCKETS("[WS][%d][handleWebsocket] got unknown opcode: %d\n", client->num, header->opCode);
+                clientDisconnect(client, 1002);
+                break;
+        }
 
-    if(payload) {
+        if(payload) {
+            free(payload);
+        }
+
+        // reset input
+        client->cWsRXsize = 0;
+#if(WEBSOCKETS_NETWORK_TYPE == NETWORK_ESP8266_ASYNC)
+        // register callback for next message
+        handleWebsocketWaitFor(client, 2);
+#endif
+
+    } else {
+        DEBUG_WEBSOCKETS("[WS][%d][handleWebsocket] missing data!\n", client->num);
         free(payload);
+        clientDisconnect(client, 1002);
     }
-
 }
 
 /**
@@ -326,13 +542,21 @@ void WebSockets::handleWebsocket(WSclient_t * client) {
  * @param clientKey String
  * @return String Accept Key
  */
-String WebSockets::acceptKey(String clientKey) {
+String WebSockets::acceptKey(String & clientKey) {
     uint8_t sha1HashBin[20] = { 0 };
 #ifdef ESP8266
     sha1(clientKey + "258EAFA5-E914-47DA-95CA-C5AB0DC85B11", &sha1HashBin[0]);
+#elif defined(ESP32)
+    String data = clientKey + "258EAFA5-E914-47DA-95CA-C5AB0DC85B11";
+    esp_sha(SHA1, (unsigned char *)data.c_str(), data.length(), &sha1HashBin[0]);
 #else
-#error todo implement sha1 for AVR
+    clientKey += "258EAFA5-E914-47DA-95CA-C5AB0DC85B11";
+    SHA1_CTX ctx;
+    SHA1Init(&ctx);
+    SHA1Update(&ctx, (const unsigned char *)clientKey.c_str(), clientKey.length());
+    SHA1Final(&sha1HashBin[0], &ctx);
 #endif
+
     String key = base64_encode(sha1HashBin, 20);
     key.trim();
 
@@ -346,13 +570,14 @@ 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);
+    size          = std::max(size, (size_t)5);    // minimum buffer size
+    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);
@@ -368,40 +593,170 @@ String WebSockets::base64_encode(uint8_t * data, size_t length) {
  * @param n size_t byte count
  * @return true if ok
  */
-bool WebSockets::readWait(WSclient_t * client, uint8_t *out, size_t n) {
-    unsigned long t = millis();
-    size_t len;
+bool WebSockets::readCb(WSclient_t * client, uint8_t * out, size_t n, WSreadWaitCb cb) {
+#if(WEBSOCKETS_NETWORK_TYPE == NETWORK_ESP8266_ASYNC)
+    if(!client->tcp || !client->tcp->connected()) {
+        return false;
+    }
 
+    client->tcp->readBytes(out, n, std::bind([](WSclient_t * client, bool ok, WSreadWaitCb cb) {
+        if(cb) {
+            cb(client, ok);
+        }
+    },
+                                       client, std::placeholders::_1, cb));
+
+#else
+    unsigned long t = millis();
+    ssize_t len;
+    DEBUG_WEBSOCKETS("[readCb] n: %zu t: %lu\n", n, t);
     while(n > 0) {
-        if(!client->tcp.connected()) {
-            DEBUG_WEBSOCKETS("[readWait] not connected!\n");
+        if(client->tcp == NULL) {
+            DEBUG_WEBSOCKETS("[readCb] tcp is null!\n");
+            if(cb) {
+                cb(client, false);
+            }
+            return false;
+        }
+
+        if(!client->tcp->connected()) {
+            DEBUG_WEBSOCKETS("[readCb] not connected!\n");
+            if(cb) {
+                cb(client, false);
+            }
             return false;
         }
 
         if((millis() - t) > WEBSOCKETS_TCP_TIMEOUT) {
-            DEBUG_WEBSOCKETS("[readWait] receive TIMEOUT!\n");
+            DEBUG_WEBSOCKETS("[readCb] receive TIMEOUT! %lu\n", (millis() - t));
+            if(cb) {
+                cb(client, false);
+            }
             return false;
         }
 
-        if(!client->tcp.available()) {
-#ifdef ESP8266
-            delay(0);
-#endif
+        if(!client->tcp->available()) {
+            WEBSOCKETS_YIELD_MORE();
             continue;
         }
 
-        len = client->tcp.read((uint8_t*) out, n);
+        len = client->tcp->read((uint8_t *)out, n);
+        if(len > 0) {
+            t = millis();
+            out += len;
+            n -= len;
+            // DEBUG_WEBSOCKETS("Receive %d left %d!\n", len, n);
+        } else {
+            // DEBUG_WEBSOCKETS("Receive %d left %d!\n", len, n);
+        }
+        if(n > 0) {
+            WEBSOCKETS_YIELD();
+        }
+    }
+    if(cb) {
+        cb(client, true);
+    }
+    WEBSOCKETS_YIELD();
+#endif
+    return true;
+}
+
+/**
+ * write x byte to tcp or get timeout
+ * @param client WSclient_t *
+ * @param out  uint8_t * data buffer
+ * @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;
+        }
+
+        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;
+        }
+
+        len = client->tcp->write((const uint8_t *)out, n);
         if(len) {
             t = millis();
             out += len;
             n -= len;
-            //DEBUG_WEBSOCKETS("Receive %d left %d!\n", len, n);
+            total += len;
+            // DEBUG_WEBSOCKETS("write %d left %d!\n", len, n);
         } else {
-            //DEBUG_WEBSOCKETS("Receive %d left %d!\n", len, n);
+            DEBUG_WEBSOCKETS("WS write %d failed left %d!\n", len, n);
+        }
+        if(n > 0) {
+            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));
+}
+
+/**
+ * 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=%lu 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);
+                }
+            }
         }
-#ifdef ESP8266
-        delay(0);
-#endif
     }
-    return true;
 }

src/WebSockets.h

@@ -25,30 +25,286 @@
 #ifndef WEBSOCKETS_H_
 #define WEBSOCKETS_H_
 
-#include <Arduino.h>
-
-#ifdef ESP8266
-#include <ESP8266WiFi.h>
+#ifdef STM32_DEVICE
+#include <application.h>
+#define bit(b) (1UL << (b))    // Taken directly from Arduino.h
 #else
-#include <UIPEthernet.h>
-#ifndef UIPETHERNET_H
-#include <Ethernet.h>
-#include <SPI.h>
-#endif
+#include <Arduino.h>
+#include <IPAddress.h>
 #endif
 
-//#define DEBUG_WEBSOCKETS(...) Serial1.printf( __VA_ARGS__ )
+#ifdef ARDUINO_ARCH_AVR
+#error Version 2.x.x currently does not support Arduino with AVR since there is no support for std namespace of c++.
+#error Use Version 1.x.x. (ATmega branch)
+#else
+#include <functional>
+#endif
+
+#include "WebSocketsVersion.h"
+
+#ifndef NODEBUG_WEBSOCKETS
+#ifdef DEBUG_ESP_PORT
+#define DEBUG_WEBSOCKETS(...)               \
+    {                                       \
+        DEBUG_ESP_PORT.printf(__VA_ARGS__); \
+        DEBUG_ESP_PORT.flush();             \
+    }
+#else
+// #define DEBUG_WEBSOCKETS(...) os_printf( __VA_ARGS__ )
+#endif
+#endif
 
 #ifndef DEBUG_WEBSOCKETS
 #define DEBUG_WEBSOCKETS(...)
+#ifndef NODEBUG_WEBSOCKETS
+#define NODEBUG_WEBSOCKETS
+#endif
 #endif
 
-#define WEBSOCKETS_MAX_DATA_SIZE  (15*1024)
-#define WEBSOCKETS_TCP_TIMEOUT    (1000)
+#if defined(ESP8266) || defined(ESP32)
+
+#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)
+#define WEBSOCKETS_YIELD_MORE() delay(1)
+#elif defined(ESP32)
+#define WEBSOCKETS_YIELD() yield()
+#define WEBSOCKETS_YIELD_MORE() delay(1)
+#endif
+
+#elif defined(STM32_DEVICE)
+
+#define WEBSOCKETS_MAX_DATA_SIZE (15 * 1024)
+#define WEBSOCKETS_USE_BIG_MEM
+#define GET_FREE_HEAP System.freeMemory()
+#define WEBSOCKETS_YIELD()
+#define WEBSOCKETS_YIELD_MORE()
+
+#elif defined(ARDUINO_ARCH_RP2040)
+
+#define WEBSOCKETS_MAX_DATA_SIZE (15 * 1024)
+#define WEBSOCKETS_USE_BIG_MEM
+#define GET_FREE_HEAP rp2040.getFreeHeap()
+#define WEBSOCKETS_YIELD() yield()
+#define WEBSOCKETS_YIELD_MORE() delay(1)
+
+#elif defined(ARDUINO_UNOWIFIR4)
+
+#define WEBSOCKETS_MAX_DATA_SIZE (15 * 1024)
+#define WEBSOCKETS_YIELD() yield()
+#define WEBSOCKETS_YIELD_MORE() delay(1)
+
+#elif defined(ARDUINO_SAMD_MKRWIFI1010) || defined(ARDUINO_SAMD_NANO_33_IOT)
+
+#define WEBSOCKETS_MAX_DATA_SIZE (15 * 1024)
+#define WEBSOCKETS_YIELD() yield()
+#define WEBSOCKETS_YIELD_MORE() delay(1)
+
+#elif defined(WIO_TERMINAL) || defined(SEEED_XIAO_M0)
+
+#define WEBSOCKETS_MAX_DATA_SIZE (15 * 1024)
+#define WEBSOCKETS_YIELD() yield()
+#define WEBSOCKETS_YIELD_MORE() delay(1)
+
+#else
+
+// atmega328p has only 2KB ram!
+#define WEBSOCKETS_MAX_DATA_SIZE (1024)
+// moves all Header strings to Flash
+#define WEBSOCKETS_SAVE_RAM
+#define WEBSOCKETS_YIELD()
+#define WEBSOCKETS_YIELD_MORE()
+#endif
+
+#ifndef WEBSOCKETS_TCP_TIMEOUT
+#define WEBSOCKETS_TCP_TIMEOUT (5000)
+#endif
+
+#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)
+#define NETWORK_RP2040 (6)
+#define NETWORK_UNOWIFIR4 (7)
+#define NETWORK_WIFI_NINA (8)
+#define NETWORK_SAMD_SEED (9)
+
+// max size of the WS Message Header
+#define WEBSOCKETS_MAX_HEADER_SIZE (14)
+
+#if !defined(WEBSOCKETS_NETWORK_TYPE)
+// select Network type based
+#if defined(ESP8266) || defined(ESP31B)
+#define WEBSOCKETS_NETWORK_TYPE NETWORK_ESP8266
+// #define WEBSOCKETS_NETWORK_TYPE NETWORK_ESP8266_ASYNC
+// #define WEBSOCKETS_NETWORK_TYPE NETWORK_W5100
+
+#elif defined(ESP32)
+#define WEBSOCKETS_NETWORK_TYPE NETWORK_ESP32
+// #define WEBSOCKETS_NETWORK_TYPE NETWORK_ESP32_ETH
+
+#elif defined(ARDUINO_ARCH_RP2040)
+#define WEBSOCKETS_NETWORK_TYPE NETWORK_RP2040
+
+#elif defined(ARDUINO_UNOWIFIR4)
+#define WEBSOCKETS_NETWORK_TYPE NETWORK_UNOWIFIR4
+
+#elif defined(ARDUINO_SAMD_MKRWIFI1010) || defined(ARDUINO_SAMD_NANO_33_IOT)
+#define WEBSOCKETS_NETWORK_TYPE NETWORK_WIFI_NINA
+
+#elif defined(WIO_TERMINAL) || defined(SEEED_XIAO_M0)
+#define WEBSOCKETS_NETWORK_TYPE NETWORK_SAMD_SEED
+
+#else
+#define WEBSOCKETS_NETWORK_TYPE NETWORK_W5100
+
+#endif
+#endif
+
+// Includes and defined based on Network Type
+#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)
+#include <WiFi.h>
+#include <WiFiClientSecure.h>
+#define SSL_AXTLS
+#elif defined(ESP31B)
+#include <ESP31BWiFi.h>
+#else
+#error "network type ESP8266 ASYNC only possible on the ESP mcu!"
+#endif
+
+#include <ESPAsyncTCP.h>
+#include <ESPAsyncTCPbuffer.h>
+#define WEBSOCKETS_NETWORK_CLASS AsyncTCPbuffer
+#define WEBSOCKETS_NETWORK_SERVER_CLASS AsyncServer
+
+#elif(WEBSOCKETS_NETWORK_TYPE == NETWORK_ESP8266)
+
+#if !defined(ESP8266) && !defined(ESP31B)
+#error "network type ESP8266 only possible on the ESP mcu!"
+#endif
+
+#ifdef ESP8266
+#include <ESP8266WiFi.h>
+#if defined(wificlientbearssl_h) && !defined(USING_AXTLS) && !defined(wificlientsecure_h)
+#define SSL_BARESSL
+#else
+#define SSL_AXTLS
+#endif
+#else
+#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)
+
+#ifdef STM32_DEVICE
+#define WEBSOCKETS_NETWORK_CLASS TCPClient
+#define WEBSOCKETS_NETWORK_SERVER_CLASS TCPServer
+#else
+#include <Ethernet.h>
+#include <SPI.h>
+#define WEBSOCKETS_NETWORK_CLASS EthernetClient
+#define WEBSOCKETS_NETWORK_SERVER_CLASS EthernetServer
+#endif
+
+#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)
+
+#include <WiFi.h>
+#include <WiFiClientSecure.h>
+#define SSL_AXTLS
+#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
+
+#elif(WEBSOCKETS_NETWORK_TYPE == NETWORK_RP2040)
+
+#include <WiFi.h>
+#include <WiFiClientSecure.h>
+#define SSL_BARESSL
+#define WEBSOCKETS_NETWORK_CLASS WiFiClient
+#define WEBSOCKETS_NETWORK_SSL_CLASS WiFiClientSecure
+#define WEBSOCKETS_NETWORK_SERVER_CLASS WiFiServer
+
+#elif(WEBSOCKETS_NETWORK_TYPE == NETWORK_UNOWIFIR4)
+
+#include <WiFiS3.h>
+#define WEBSOCKETS_NETWORK_CLASS WiFiClient
+#define WEBSOCKETS_NETWORK_SERVER_CLASS WiFiServer
+
+#elif(WEBSOCKETS_NETWORK_TYPE == NETWORK_WIFI_NINA)
+#if __has_include(<WiFiNINA.h>)
+#include <WiFiNINA.h>
+#else
+#error "Please install WiFiNINA library!"
+#endif
+
+#define WEBSOCKETS_NETWORK_CLASS WiFiClient
+#define WEBSOCKETS_NETWORK_SERVER_CLASS WiFiServer
+#define WEBSOCKETS_NETWORK_SSL_CLASS WiFiSSLClient
+
+#elif(WEBSOCKETS_NETWORK_TYPE == NETWORK_SAMD_SEED)
+#if __has_include(<rpcWiFi.h>) && __has_include(<rpcWiFiClientSecure.h>)
+#include <rpcWiFi.h>
+#include <rpcWiFiClientSecure.h>
+#else
+#error "Please install rpcWiFi library!"
+#endif
+
+#define WEBSOCKETS_NETWORK_CLASS WiFiClient
+#define WEBSOCKETS_NETWORK_SERVER_CLASS WiFiServer
+#define WEBSOCKETS_NETWORK_SSL_CLASS WiFiClientSecure
+
+#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)
+#else
+#define WEBSOCKETS_STRING(var) var
+#endif
 
 typedef enum {
     WSC_NOT_CONNECTED,
     WSC_HEADER,
+    WSC_BODY,
     WSC_CONNECTED
 } WSclientsStatus_t;
 
@@ -57,65 +313,142 @@ typedef enum {
     WStype_DISCONNECTED,
     WStype_CONNECTED,
     WStype_TEXT,
-    WStype_BIN
+    WStype_BIN,
+    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 {
-        uint8_t num; ///< connection number
+    bool fin;
+    bool rsv1;
+    bool rsv2;
+    bool rsv3;
 
-        WSclientsStatus_t status;
-#ifdef ESP8266
-        WiFiClient tcp;
-#else
-#ifdef UIPETHERNET_H
-        UIPClient tcp;
-#else
-        EthernetClient tcp;
+    WSopcode_t opCode;
+    bool mask;
+
+    size_t payloadLen;
+
+    uint8_t * maskKey;
+} WSMessageHeader_t;
+
+typedef struct {
+    void init(uint8_t num,
+        uint32_t pingInterval,
+        uint32_t pongTimeout,
+        uint8_t disconnectTimeoutCount) {
+        this->num                    = num;
+        this->pingInterval           = pingInterval;
+        this->pongTimeout            = pongTimeout;
+        this->disconnectTimeoutCount = disconnectTimeoutCount;
+    }
+
+    uint8_t num = 0;    ///< connection number
+
+    WSclientsStatus_t status = WSC_NOT_CONNECTED;
+
+    WEBSOCKETS_NETWORK_CLASS * tcp = nullptr;
+
+    bool isSocketIO = false;    ///< client for socket.io server
+
+#if defined(HAS_SSL)
+    bool isSSL = false;    ///< run in ssl mode
+    WEBSOCKETS_NETWORK_SSL_CLASS * ssl;
 #endif
+
+    String cUrl;           ///< http url
+    uint16_t cCode = 0;    ///< http code
+
+    bool cIsClient    = false;    ///< will be used for masking
+    bool cIsUpgrade   = false;    ///< Connection == Upgrade
+    bool cIsWebsocket = false;    ///< 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 = 0;    ///< client Sec-WebSocket-Version
+
+    uint8_t cWsRXsize = 0;                            ///< 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 extraHeaders;
+
+    bool cHttpHeadersValid = false;    ///< non-websocket http header validity indicator
+    size_t cMandatoryHeadersCount;     ///< non-websocket mandatory http headers present count
+
+    bool pongReceived              = false;
+    uint32_t pingInterval          = 0;    // how often ping will be sent, 0 means "heartbeat is not active"
+    uint32_t lastPing              = 0;    // millis when last pong has been received
+    uint32_t pongTimeout           = 0;    // interval in millis after which pong is considered to timeout
+    uint8_t disconnectTimeoutCount = 0;    // after how many subsequent pong timeouts discconnect will happen, 0 means "do not disconnect"
+    uint8_t pongTimeoutCount       = 0;    // current pong timeout count
+
+#if(WEBSOCKETS_NETWORK_TYPE == NETWORK_ESP8266_ASYNC)
+    String cHttpLine;    ///< HTTP header lines
 #endif
-        String cUrl;        ///< http url
-        uint16_t cCode;     ///< http code
-
-        bool cIsUpgrade;    ///< Connection == Upgrade
-        bool cIsWebsocket;  ///< Upgrade == websocket
-
-        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
 
 } WSclient_t;
 
 class WebSockets {
-    protected:
-        virtual void clientDisconnect(WSclient_t * client);
-        virtual bool clientIsConnected(WSclient_t * client);
+  protected:
+#ifdef __AVR__
+    typedef void (*WSreadWaitCb)(WSclient_t * client, bool ok);
+#else
+    typedef std::function<void(WSclient_t * client, bool ok)> WSreadWaitCb;
+#endif
 
-        virtual void messageRecived(WSclient_t * client, WSopcode_t opcode, uint8_t * payload, size_t length);
+    virtual void clientDisconnect(WSclient_t * client)  = 0;
+    virtual bool clientIsConnected(WSclient_t * client) = 0;
 
-        void clientDisconnect(WSclient_t * client, uint16_t code, char * reason = NULL, size_t reasonLen = 0);
-        void sendFrame(WSclient_t * client, WSopcode_t opcode, uint8_t * payload = NULL, size_t length = 0, bool mask = false, bool fin = true, bool headerToPayload = false);
+    void clientDisconnect(WSclient_t * client, uint16_t code, char * reason = NULL, size_t reasonLen = 0);
 
+    virtual void messageReceived(WSclient_t * client, WSopcode_t opcode, uint8_t * payload, size_t length, bool fin) = 0;
 
-        void handleWebsocket(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);
 
-        bool readWait(WSclient_t * client, uint8_t *out, size_t n);
+    void headerDone(WSclient_t * client);
 
-        String acceptKey(String clientKey);
-        String base64_encode(uint8_t * data, size_t length);
+    void handleWebsocket(WSclient_t * client);
 
+    bool handleWebsocketWaitFor(WSclient_t * client, size_t size);
+    void handleWebsocketCb(WSclient_t * client);
+    void handleWebsocketPayloadCb(WSclient_t * client, bool ok, uint8_t * payload);
+
+    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
+#define UNUSED(var) (void)(var)
+#endif
 #endif /* WEBSOCKETS_H_ */

src/WebSockets4WebServer.h

@@ -0,0 +1,86 @@
+/**
+ * @file WebSocketsServer.cpp
+ * @date 28.10.2020
+ * @author Markus Sattler & esp8266/arduino community
+ *
+ * Copyright (c) 2020 Markus Sattler. All rights reserved.
+ * This file is part of the WebSockets for Arduino.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+ *
+ */
+
+#ifndef __WEBSOCKETS4WEBSERVER_H
+#define __WEBSOCKETS4WEBSERVER_H
+
+#include <WebSocketsServer.h>
+#include <ESP8266WebServer.h>
+
+#if((WEBSOCKETS_NETWORK_TYPE == NETWORK_ESP8266) || (WEBSOCKETS_NETWORK_TYPE == NETWORK_RP2040)) && WEBSERVER_HAS_HOOK
+
+class WebSockets4WebServer : public WebSocketsServerCore {
+#if defined(ESP8266)
+    using WebServerClass = ESP8266WebServer;
+#else
+    using WebServerClass = WebServer;
+#endif
+
+  public:
+    WebSockets4WebServer(const String & origin = "", const String & protocol = "arduino")
+        : WebSocketsServerCore(origin, protocol) {
+        begin();
+    }
+
+    WebServerClass::HookFunction hookForWebserver(const String & wsRootDir, WebSocketServerEvent event) {
+        onEvent(event);
+
+        return [&, wsRootDir](const String & method, const String & url, WiFiClient * tcpClient, WebServerClass::ContentTypeFunction contentType) {
+            (void)contentType;
+
+            if(!(method == "GET" && url.indexOf(wsRootDir) == 0)) {
+                return WebServerClass::CLIENT_REQUEST_CAN_CONTINUE;
+            }
+
+            // allocate a WiFiClient copy (like in WebSocketsServer::handleNewClients())
+            WEBSOCKETS_NETWORK_CLASS * newTcpClient = new WEBSOCKETS_NETWORK_CLASS(*tcpClient);
+
+            // Then initialize a new WSclient_t (like in WebSocketsServer::handleNewClient())
+            WSclient_t * client = handleNewClient(newTcpClient);
+
+            if(client) {
+                // give "GET <url>"
+                String headerLine;
+                headerLine.reserve(url.length() + 5);
+                headerLine = "GET ";
+                headerLine += url;
+                handleHeader(client, &headerLine);
+            }
+
+            // tell webserver to not close but forget about this client
+            return WebServerClass::CLIENT_IS_GIVEN;
+        };
+    }
+};
+#else    // WEBSOCKETS_NETWORK_TYPE == NETWORK_ESP8266 && WEBSERVER_HAS_HOOK
+
+#ifndef WEBSERVER_HAS_HOOK
+#error Your current Framework / Arduino core version does not support Webserver Hook Functions
+#else
+#error Your Hardware Platform does not support Webserver Hook Functions
+#endif
+
+#endif    // WEBSOCKETS_NETWORK_TYPE == NETWORK_ESP8266 && WEBSERVER_HAS_HOOK
+
+#endif    // __WEBSOCKETS4WEBSERVER_H

src/WebSocketsClient.h

@@ -25,65 +25,167 @@
 #ifndef WEBSOCKETSCLIENT_H_
 #define WEBSOCKETSCLIENT_H_
 
-#include <Arduino.h>
-
-#ifdef ESP8266
-#include <ESP8266WiFi.h>
-#else
-#include <UIPEthernet.h>
-#ifndef UIPETHERNET_H
-#include <Ethernet.h>
-#include <SPI.h>
-#endif
-#endif
-
 #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);
+#else
+    typedef std::function<void(WStype_t type, uint8_t * payload, size_t length)> WebSocketClientEvent;
+#endif
 
-        typedef void (*WebSocketClientEvent)(WStype_t type, uint8_t * payload, size_t length);
+    WebSocketsClient(void);
+    virtual ~WebSocketsClient(void);
 
-        WebSocketsClient(void);
-        ~WebSocketsClient(void);
+    void begin(const char * host, uint16_t port, const char * url = "/", const char * protocol = "arduino");
+    void begin(String host, uint16_t port, String url = "/", String protocol = "arduino");
+    void begin(IPAddress host, uint16_t port, const char * url = "/", const char * protocol = "arduino");
 
-        void begin(const char *host, uint16_t port, const char * url = "/");
-        void begin(String host, uint16_t port, String url = "/");
+#if defined(HAS_SSL)
+#ifdef SSL_AXTLS
+    void beginSSL(const char * host, uint16_t port, const char * url = "/", const char * fingerprint = "", const char * protocol = "arduino");
+    void beginSSL(String host, uint16_t port, String url = "/", String fingerprint = "", String protocol = "arduino");
+#else
+    void beginSSL(const char * host, uint16_t port, const char * url = "/", const uint8_t * fingerprint = NULL, const char * protocol = "arduino");
+#if defined(SSL_BARESSL)
+    void beginSslWithCA(const char * host, uint16_t port, const char * url = "/", BearSSL::X509List * CA_cert = NULL, const char * protocol = "arduino");
+    void setSSLClientCertKey(BearSSL::X509List * clientCert = NULL, BearSSL::PrivateKey * clientPrivateKey = NULL);
+#endif
+    void setSSLClientCertKey(const char * clientCert = NULL, const char * clientPrivateKey = NULL);
+#endif
+    void beginSslWithCA(const char * host, uint16_t port, const char * url = "/", const char * CA_cert = NULL, const char * protocol = "arduino");
+#ifdef ESP32
+#if ESP_ARDUINO_VERSION >= ESP_ARDUINO_VERSION_VAL(3, 0, 4)
+    void beginSslWithBundle(const char * host, uint16_t port, const char * url = "/", const uint8_t * CA_bundle = NULL, size_t CA_bundle_size = 0, const char * protocol = "arduino");
+#else
+    void beginSslWithBundle(const char * host, uint16_t port, const char * url = "/", const uint8_t * CA_bundle = NULL, const char * protocol = "arduino");
+#endif
+#endif
+#endif
 
-        void loop(void);
+    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 onEvent(WebSocketClientEvent cbEvent);
+#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 sendTXT(uint8_t * payload, size_t length = 0, bool headerToPayload = false);
-        void sendTXT(const uint8_t * payload, size_t length = 0);
-        void sendTXT(char * payload, size_t length = 0, bool headerToPayload = false);
-        void sendTXT(const char * payload, size_t length = 0);
-        void sendTXT(String payload);
+    void beginSocketIOSSLWithCA(const char * host, uint16_t port, const char * url = "/socket.io/?EIO=3", const char * CA_cert = NULL, const char * protocol = "arduino");
+#if defined(SSL_BARESSL)
+    void beginSocketIOSSLWithCA(const char * host, uint16_t port, const char * url = "/socket.io/?EIO=3", BearSSL::X509List * CA_cert = NULL, const char * protocol = "arduino");
+#endif
+#endif
 
-        void sendBIN(uint8_t * payload, size_t length, bool headerToPayload = false);
-        void sendBIN(const uint8_t * payload, size_t length);
+#if(WEBSOCKETS_NETWORK_TYPE != NETWORK_ESP8266_ASYNC)
+    void loop(void);
+#else
+    // Async interface not need a loop call
+    void loop(void) __attribute__((deprecated)) {}
+#endif
 
-        void disconnect(void);
+    void onEvent(WebSocketClientEvent cbEvent);
 
-    protected:
-        String _host;
-        uint16_t _port;
+    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);
 
-        WSclient_t _client;
+    bool sendBIN(uint8_t * payload, size_t length, bool headerToPayload = false);
+    bool sendBIN(const uint8_t * payload, size_t length);
 
-        WebSocketClientEvent _cbEvent;
+    bool sendPing(uint8_t * payload = NULL, size_t length = 0);
+    bool sendPing(String & payload);
 
-        void messageRecived(WSclient_t * client, WSopcode_t opcode, uint8_t * payload, size_t length);
+    void disconnect(void);
 
-        void clientDisconnect(WSclient_t * client);
-        bool clientIsConnected(WSclient_t * client);
+    void setAuthorization(const char * user, const char * password);
+    void setAuthorization(const char * auth);
 
-        void handleNewClients(void);
-        void handleClientData(void);
+    void setExtraHeaders(const char * extraHeaders = NULL);
 
-        void sendHeader(WSclient_t * client);
-        void handleHeader(WSclient_t * client);
+    void setReconnectInterval(unsigned long time);
 
+    void enableHeartbeat(uint32_t pingInterval, uint32_t pongTimeout, uint8_t disconnectTimeoutCount);
+    void disableHeartbeat();
+
+    bool isConnected(void);
+
+  protected:
+    String _host;
+    uint16_t _port;
+
+#if defined(HAS_SSL)
+#ifdef SSL_AXTLS
+    String _fingerprint;
+    const char * _CA_cert;
+    const uint8_t * _CA_bundle;
+#if defined(ESP32)
+#if ESP_ARDUINO_VERSION >= ESP_ARDUINO_VERSION_VAL(3, 0, 4)
+    size_t _CA_bundle_size;
+#endif
+#endif
+#define SSL_FINGERPRINT_IS_SET (_fingerprint.length())
+#define SSL_FINGERPRINT_NULL ""
+#else
+    const uint8_t * _fingerprint;
+#if defined(SSL_BARESSL)
+    BearSSL::X509List * _CA_cert;
+    BearSSL::X509List * _client_cert;
+    BearSSL::PrivateKey * _client_key;
+#endif
+#define SSL_FINGERPRINT_IS_SET (_fingerprint != NULL)
+#define SSL_FINGERPRINT_NULL NULL
+#endif
+
+#if(WEBSOCKETS_NETWORK_TYPE == NETWORK_SAMD_SEED) || (WEBSOCKETS_NETWORK_TYPE == NETWORK_WIFI_NINA)
+    const char * _CA_cert;
+    const uint8_t * _CA_bundle;
+#endif
+
+#endif
+    WSclient_t _client;
+
+    WebSocketClientEvent _cbEvent;
+
+    unsigned long _lastConnectionFail;
+    unsigned long _reconnectInterval;
+    unsigned long _lastHeaderSent;
+
+    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);
+
+#if(WEBSOCKETS_NETWORK_TYPE != NETWORK_ESP8266_ASYNC)
+    void handleClientData(void);
+#endif
+
+    void sendHeader(WSclient_t * client);
+    void handleHeader(WSclient_t * client, String * headerLine);
+
+    void connectedCb();
+    void connectFailedCb();
+
+    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);
+        }
+    }
 };
 
 #endif /* WEBSOCKETSCLIENT_H_ */

src/WebSocketsServer.h

@@ -25,109 +25,219 @@
 #ifndef WEBSOCKETSSERVER_H_
 #define WEBSOCKETSSERVER_H_
 
-#include <Arduino.h>
-
-#ifdef ESP8266
-#include <ESP8266WiFi.h>
-#else
-#include <UIPEthernet.h>
-#ifndef UIPETHERNET_H
-#include <Ethernet.h>
-#include <SPI.h>
-#endif
-#endif
-
 #include "WebSockets.h"
 
-#define WEBSOCKETS_SERVER_CLIENT_MAX  (5)
-
-
-
-
-class WebSocketsServer: private WebSockets {
-public:
-
-        typedef void (*WebSocketServerEvent)(uint8_t num, WStype_t type, uint8_t * payload, size_t length);
-
-        WebSocketsServer(uint16_t port);
-        ~WebSocketsServer(void);
-
-        void begin(void);
-        void loop(void);
-
-        void onEvent(WebSocketServerEvent cbEvent);
-
-
-        void sendTXT(uint8_t num, uint8_t * payload, size_t length = 0, bool headerToPayload = false);
-        void sendTXT(uint8_t num, const uint8_t * payload, size_t length = 0);
-        void sendTXT(uint8_t num, char * payload, size_t length = 0, bool headerToPayload = false);
-        void sendTXT(uint8_t num, const char * payload, size_t length = 0);
-        void sendTXT(uint8_t num, String payload);
-
-        void broadcastTXT(uint8_t * payload, size_t length = 0, bool headerToPayload = false);
-        void broadcastTXT(const uint8_t * payload, size_t length = 0);
-        void broadcastTXT(char * payload, size_t length = 0, bool headerToPayload = false);
-        void broadcastTXT(const char * payload, size_t length = 0);
-        void broadcastTXT(String payload);
-
-        void sendBIN(uint8_t num, uint8_t * payload, size_t length, bool headerToPayload = false);
-        void sendBIN(uint8_t num, const uint8_t * payload, size_t length);
-
-        void broadcastBIN(uint8_t * payload, size_t length, bool headerToPayload = false);
-        void broadcastBIN(const uint8_t * payload, size_t length);
-
-        void disconnect(void);
-        void disconnect(uint8_t num);
-
-        IPAddress remoteIP(uint8_t num);
-
-protected:
-        uint16_t _port;
-
-#ifdef ESP8266
-        WiFiServer * _server;
-#else
-#ifdef UIPETHERNET_H
-        UIPServer * _server;
-#else
-        EthernetServer * _server;
-#endif
+#ifndef WEBSOCKETS_SERVER_CLIENT_MAX
+#define WEBSOCKETS_SERVER_CLIENT_MAX (5)
 #endif
 
-        WSclient_t _clients[WEBSOCKETS_SERVER_CLIENT_MAX];
+class WebSocketsServerCore : protected WebSockets {
+  public:
+    WebSocketsServerCore(const String & origin = "", const String & protocol = "arduino");
+    virtual ~WebSocketsServerCore(void);
 
-        WebSocketServerEvent _cbEvent;
+    void begin(void);
+    void close(void);
 
-        void messageRecived(WSclient_t * client, WSopcode_t opcode, uint8_t * payload, size_t length);
+#ifdef __AVR__
+    typedef void (*WebSocketServerEvent)(uint8_t num, WStype_t type, uint8_t * payload, size_t length);
+    typedef bool (*WebSocketServerHttpHeaderValFunc)(String headerName, String headerValue);
+#else
+    typedef std::function<void(uint8_t num, WStype_t type, uint8_t * payload, size_t length)> WebSocketServerEvent;
+    typedef std::function<bool(String headerName, String headerValue)> WebSocketServerHttpHeaderValFunc;
+#endif
 
-        void clientDisconnect(WSclient_t * client);
-        bool clientIsConnected(WSclient_t * client);
+    void onEvent(WebSocketServerEvent cbEvent);
+    void onValidateHttpHeader(
+        WebSocketServerHttpHeaderValFunc validationFunc,
+        const char * mandatoryHttpHeaders[],
+        size_t mandatoryHttpHeaderCount);
 
-        void handleNewClients(void);
-        void handleClientData(void);
+    bool sendTXT(uint8_t num, uint8_t * payload, size_t length = 0, bool headerToPayload = false);
+    bool sendTXT(uint8_t num, const uint8_t * payload, size_t length = 0);
+    bool sendTXT(uint8_t num, char * payload, size_t length = 0, bool headerToPayload = false);
+    bool sendTXT(uint8_t num, const char * payload, size_t length = 0);
+    bool sendTXT(uint8_t num, String & payload);
 
-        void handleHeader(WSclient_t * client);
+    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);
 
-        /**
-         * called if a non Websocket connection is comming in.
-         * Note: can be overrided
-         * @param client WSclient_t *  ptr to the client struct
-         */
-        virtual void handleNonWebsocketConnection(WSclient_t * client) {
-            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);
+    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 sendPing(uint8_t num, uint8_t * payload = NULL, size_t length = 0);
+    bool sendPing(uint8_t num, String & payload);
+
+    bool broadcastPing(uint8_t * payload = NULL, size_t length = 0);
+    bool broadcastPing(String & payload);
+
+    void disconnect(void);
+    void disconnect(uint8_t num);
+
+    void setAuthorization(const char * user, const char * password);
+    void setAuthorization(const char * auth);
+
+    int connectedClients(bool ping = false);
+
+    bool clientIsConnected(uint8_t num);
+
+    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) || (WEBSOCKETS_NETWORK_TYPE == NETWORK_RP2040)
+    IPAddress remoteIP(uint8_t num);
+#endif
+
+#if(WEBSOCKETS_NETWORK_TYPE != NETWORK_ESP8266_ASYNC)
+    void loop(void);    // handle client data only
+#endif
+
+    WSclient_t * newClient(WEBSOCKETS_NETWORK_CLASS * TCPclient);
+
+  protected:
+    String _origin;
+    String _protocol;
+    String _base64Authorization;    ///< Base64 encoded Auth request
+    String * _mandatoryHttpHeaders;
+    size_t _mandatoryHttpHeaderCount;
+
+    WSclient_t _clients[WEBSOCKETS_SERVER_CLIENT_MAX];
+
+    WebSocketServerEvent _cbEvent;
+    WebSocketServerHttpHeaderValFunc _httpHeaderValidationFunc;
+
+    bool _runnning;
+
+    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);
+
+    void clientDisconnect(WSclient_t * client);
+    bool clientIsConnected(WSclient_t * client);
+
+#if(WEBSOCKETS_NETWORK_TYPE != NETWORK_ESP8266_ASYNC)
+    void handleClientData(void);
+#endif
+
+    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);
+    }
+
+    /**
+     * called if a non Authorization connection is coming in.
+     * Note: can be override
+     * @param client WSclient_t *  ptr to the client struct
+     */
+    virtual void handleAuthorizationFailed(WSclient_t * client) {
+        client->tcp->write(
+            "HTTP/1.1 401 Unauthorized\r\n"
+            "Server: arduino-WebSocket-Server\r\n"
+            "Content-Type: text/plain\r\n"
+            "Content-Length: 45\r\n"
+            "Connection: close\r\n"
+            "Sec-WebSocket-Version: 13\r\n"
+            "WWW-Authenticate: Basic realm=\"WebSocket Server\""
+            "\r\n"
+            "This Websocket server requires Authorization!");
+        clientDisconnect(client);
+    }
+
+    /**
+     * called for sending a Event to the app
+     * @param num uint8_t
+     * @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);
         }
+    }
 
+    /*
+     * Called at client socket connect handshake negotiation time for each http header that is not
+     * a websocket specific http header (not Connection, Upgrade, Sec-WebSocket-*)
+     * If the custom httpHeaderValidationFunc returns false for any headerName / headerValue passed, the
+     * socket negotiation is considered invalid and the upgrade to websockets request is denied / rejected
+     * This mechanism can be used to enable custom authentication schemes e.g. test the value
+     * of a session cookie to determine if a user is logged on / authenticated
+     */
+    virtual bool execHttpHeaderValidation(String headerName, String headerValue) {
+        if(_httpHeaderValidationFunc) {
+            // return the value of the custom http header validation function
+            return _httpHeaderValidationFunc(headerName, headerValue);
+        }
+        // no custom http header validation so just assume all is good
+        return true;
+    }
+
+#if(WEBSOCKETS_NETWORK_TYPE != NETWORK_ESP8266_ASYNC)
+    WSclient_t * handleNewClient(WEBSOCKETS_NETWORK_CLASS * tcpClient);
+#endif
+
+    /**
+     * drop native tcp connection (client->tcp)
+     */
+    void dropNativeClient(WSclient_t * client);
+
+  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);
 };
 
+class WebSocketsServer : public WebSocketsServerCore {
+  public:
+    WebSocketsServer(uint16_t port, const String & origin = "", const String & protocol = "arduino");
+    virtual ~WebSocketsServer(void);
 
+    void begin(void);
+    void close(void);
+
+#if(WEBSOCKETS_NETWORK_TYPE != NETWORK_ESP8266_ASYNC)
+    void loop(void);    // handle incoming client and client data
+#else
+    // Async interface not need a loop call
+    void loop(void) __attribute__((deprecated)) {}
+#endif
+
+  protected:
+#if(WEBSOCKETS_NETWORK_TYPE != NETWORK_ESP8266_ASYNC)
+    void handleNewClients(void);
+#endif
+
+    uint16_t _port;
+    WEBSOCKETS_NETWORK_SERVER_CLASS * _server;
+};
 
 #endif /* WEBSOCKETSSERVER_H_ */

src/WebSocketsVersion.h

@@ -0,0 +1,36 @@
+/**
+ * @file WebSocketsVersion.h
+ * @date 06.09.2024
+ * @author Markus Sattler
+ *
+ * Copyright (c) 2015 Markus Sattler. All rights reserved.
+ * This file is part of the WebSockets for Arduino.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+ *
+ */
+
+#ifndef WEBSOCKETSVERSION_H_
+#define WEBSOCKETSVERSION_H_
+
+#define WEBSOCKETS_VERSION "2.6.1"
+
+#define WEBSOCKETS_VERSION_MAJOR 2
+#define WEBSOCKETS_VERSION_MINOR 6
+#define WEBSOCKETS_VERSION_PATCH 1
+
+#define WEBSOCKETS_VERSION_INT 2006001
+
+#endif /* WEBSOCKETSVERSION_H_ */

src/libb64/cdecode.c

@@ -5,7 +5,16 @@ This is part of the libb64 project, and has been placed in the public domain.
 For details, see http://sourceforge.net/projects/libb64
 */
 
-#include "cdecode.h"
+#ifdef ESP8266
+#include <core_esp8266_features.h>
+#endif
+
+#if defined(ESP32) || defined(ARDUINO_ARCH_RP2040) || defined(WIO_TERMINAL) || defined(SEEED_XIAO_M0)
+#define CORE_HAS_LIBB64
+#endif
+
+#ifndef CORE_HAS_LIBB64
+#include "cdecode_inc.h"
 
 int base64_decode_value(char value_in)
 {
@@ -27,9 +36,9 @@ int base64_decode_block(const char* code_in, const int length_in, char* plaintex
 	const char* codechar = code_in;
 	char* plainchar = plaintext_out;
 	char fragment;
-	
+
 	*plainchar = state_in->plainchar;
-	
+
 	switch (state_in->step)
 	{
 		while (1)
@@ -86,3 +95,4 @@ int base64_decode_block(const char* code_in, const int length_in, char* plaintex
 	return plainchar - plaintext_out;
 }
 
+#endif

src/libb64/cencode.c

@@ -5,7 +5,16 @@ This is part of the libb64 project, and has been placed in the public domain.
 For details, see http://sourceforge.net/projects/libb64
 */
 
-#include "cencode.h"
+#ifdef ESP8266
+#include <core_esp8266_features.h>
+#endif
+
+#if defined(ESP32) || defined(ARDUINO_ARCH_RP2040) || defined(WIO_TERMINAL) || defined(SEEED_XIAO_M0)
+#define CORE_HAS_LIBB64
+#endif
+
+#ifndef CORE_HAS_LIBB64
+#include "cencode_inc.h"
 
 const int CHARS_PER_LINE = 72;
 
@@ -30,9 +39,9 @@ int base64_encode_block(const char* plaintext_in, int length_in, char* code_out,
 	char* codechar = code_out;
 	char result;
 	char fragment;
-	
+
 	result = state_in->result;
-	
+
 	switch (state_in->step)
 	{
 		while (1)
@@ -71,7 +80,7 @@ int base64_encode_block(const char* plaintext_in, int length_in, char* code_out,
 			*codechar++ = base64_encode_value(result);
 			result  = (fragment & 0x03f) >> 0;
 			*codechar++ = base64_encode_value(result);
-			
+
 			++(state_in->stepcount);
 			if (state_in->stepcount == CHARS_PER_LINE/4)
 			{
@@ -87,7 +96,7 @@ int base64_encode_block(const char* plaintext_in, int length_in, char* code_out,
 int base64_encode_blockend(char* code_out, base64_encodestate* state_in)
 {
 	char* codechar = code_out;
-	
+
 	switch (state_in->step)
 	{
 	case step_B:
@@ -103,7 +112,8 @@ int base64_encode_blockend(char* code_out, base64_encodestate* state_in)
 		break;
 	}
 	*codechar++ = 0x00;
-	
+
 	return codechar - code_out;
 }
 
+#endif

src/libsha1/libsha1.c

@@ -0,0 +1,202 @@
+/* from valgrind tests */
+
+/* ================ sha1.c ================ */
+/*
+SHA-1 in C
+By Steve Reid <steve@edmweb.com>
+100% Public Domain
+
+Test Vectors (from FIPS PUB 180-1)
+"abc"
+  A9993E36 4706816A BA3E2571 7850C26C 9CD0D89D
+"abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq"
+  84983E44 1C3BD26E BAAE4AA1 F95129E5 E54670F1
+A million repetitions of "a"
+  34AA973C D4C4DAA4 F61EEB2B DBAD2731 6534016F
+*/
+
+/* #define LITTLE_ENDIAN * This should be #define'd already, if true. */
+/* #define SHA1HANDSOFF * Copies data before messing with it. */
+
+#if !defined(ESP8266) && !defined(ESP32)
+
+#define SHA1HANDSOFF
+
+#include <stdio.h>
+#include <string.h>
+#include <stdint.h>
+
+#include "libsha1.h"
+
+
+#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits))))
+
+/* blk0() and blk() perform the initial expand. */
+/* I got the idea of expanding during the round function from SSLeay */
+#if BYTE_ORDER == LITTLE_ENDIAN
+#define blk0(i) (block->l[i] = (rol(block->l[i],24)&0xFF00FF00) \
+    |(rol(block->l[i],8)&0x00FF00FF))
+#elif BYTE_ORDER == BIG_ENDIAN
+#define blk0(i) block->l[i]
+#else
+#error "Endianness not defined!"
+#endif
+#define blk(i) (block->l[i&15] = rol(block->l[(i+13)&15]^block->l[(i+8)&15] \
+    ^block->l[(i+2)&15]^block->l[i&15],1))
+
+/* (R0+R1), R2, R3, R4 are the different operations used in SHA1 */
+#define R0(v,w,x,y,z,i) z+=((w&(x^y))^y)+blk0(i)+0x5A827999+rol(v,5);w=rol(w,30);
+#define R1(v,w,x,y,z,i) z+=((w&(x^y))^y)+blk(i)+0x5A827999+rol(v,5);w=rol(w,30);
+#define R2(v,w,x,y,z,i) z+=(w^x^y)+blk(i)+0x6ED9EBA1+rol(v,5);w=rol(w,30);
+#define R3(v,w,x,y,z,i) z+=(((w|x)&y)|(w&x))+blk(i)+0x8F1BBCDC+rol(v,5);w=rol(w,30);
+#define R4(v,w,x,y,z,i) z+=(w^x^y)+blk(i)+0xCA62C1D6+rol(v,5);w=rol(w,30);
+
+
+/* Hash a single 512-bit block. This is the core of the algorithm. */
+
+void SHA1Transform(uint32_t state[5], const unsigned char buffer[64])
+{
+    uint32_t a, b, c, d, e;
+    typedef union {
+        unsigned char c[64];
+        uint32_t l[16];
+    } CHAR64LONG16;
+#ifdef SHA1HANDSOFF
+    CHAR64LONG16 block[1];  /* use array to appear as a pointer */
+    memcpy(block, buffer, 64);
+#else
+    /* The following had better never be used because it causes the
+     * pointer-to-const buffer to be cast into a pointer to non-const.
+     * And the result is written through.  I threw a "const" in, hoping
+     * this will cause a diagnostic.
+     */
+    CHAR64LONG16* block = (const CHAR64LONG16*)buffer;
+#endif
+    /* Copy context->state[] to working vars */
+    a = state[0];
+    b = state[1];
+    c = state[2];
+    d = state[3];
+    e = state[4];
+    /* 4 rounds of 20 operations each. Loop unrolled. */
+    R0(a,b,c,d,e, 0); R0(e,a,b,c,d, 1); R0(d,e,a,b,c, 2); R0(c,d,e,a,b, 3);
+    R0(b,c,d,e,a, 4); R0(a,b,c,d,e, 5); R0(e,a,b,c,d, 6); R0(d,e,a,b,c, 7);
+    R0(c,d,e,a,b, 8); R0(b,c,d,e,a, 9); R0(a,b,c,d,e,10); R0(e,a,b,c,d,11);
+    R0(d,e,a,b,c,12); R0(c,d,e,a,b,13); R0(b,c,d,e,a,14); R0(a,b,c,d,e,15);
+    R1(e,a,b,c,d,16); R1(d,e,a,b,c,17); R1(c,d,e,a,b,18); R1(b,c,d,e,a,19);
+    R2(a,b,c,d,e,20); R2(e,a,b,c,d,21); R2(d,e,a,b,c,22); R2(c,d,e,a,b,23);
+    R2(b,c,d,e,a,24); R2(a,b,c,d,e,25); R2(e,a,b,c,d,26); R2(d,e,a,b,c,27);
+    R2(c,d,e,a,b,28); R2(b,c,d,e,a,29); R2(a,b,c,d,e,30); R2(e,a,b,c,d,31);
+    R2(d,e,a,b,c,32); R2(c,d,e,a,b,33); R2(b,c,d,e,a,34); R2(a,b,c,d,e,35);
+    R2(e,a,b,c,d,36); R2(d,e,a,b,c,37); R2(c,d,e,a,b,38); R2(b,c,d,e,a,39);
+    R3(a,b,c,d,e,40); R3(e,a,b,c,d,41); R3(d,e,a,b,c,42); R3(c,d,e,a,b,43);
+    R3(b,c,d,e,a,44); R3(a,b,c,d,e,45); R3(e,a,b,c,d,46); R3(d,e,a,b,c,47);
+    R3(c,d,e,a,b,48); R3(b,c,d,e,a,49); R3(a,b,c,d,e,50); R3(e,a,b,c,d,51);
+    R3(d,e,a,b,c,52); R3(c,d,e,a,b,53); R3(b,c,d,e,a,54); R3(a,b,c,d,e,55);
+    R3(e,a,b,c,d,56); R3(d,e,a,b,c,57); R3(c,d,e,a,b,58); R3(b,c,d,e,a,59);
+    R4(a,b,c,d,e,60); R4(e,a,b,c,d,61); R4(d,e,a,b,c,62); R4(c,d,e,a,b,63);
+    R4(b,c,d,e,a,64); R4(a,b,c,d,e,65); R4(e,a,b,c,d,66); R4(d,e,a,b,c,67);
+    R4(c,d,e,a,b,68); R4(b,c,d,e,a,69); R4(a,b,c,d,e,70); R4(e,a,b,c,d,71);
+    R4(d,e,a,b,c,72); R4(c,d,e,a,b,73); R4(b,c,d,e,a,74); R4(a,b,c,d,e,75);
+    R4(e,a,b,c,d,76); R4(d,e,a,b,c,77); R4(c,d,e,a,b,78); R4(b,c,d,e,a,79);
+    /* Add the working vars back into context.state[] */
+    state[0] += a;
+    state[1] += b;
+    state[2] += c;
+    state[3] += d;
+    state[4] += e;
+    /* Wipe variables */
+    a = b = c = d = e = 0;
+#ifdef SHA1HANDSOFF
+    memset(block, '\0', sizeof(block));
+#endif
+}
+
+
+/* SHA1Init - Initialize new context */
+
+void SHA1Init(SHA1_CTX* context)
+{
+    /* SHA1 initialization constants */
+    context->state[0] = 0x67452301;
+    context->state[1] = 0xEFCDAB89;
+    context->state[2] = 0x98BADCFE;
+    context->state[3] = 0x10325476;
+    context->state[4] = 0xC3D2E1F0;
+    context->count[0] = context->count[1] = 0;
+}
+
+
+/* Run your data through this. */
+
+void SHA1Update(SHA1_CTX* context, const unsigned char* data, uint32_t len)
+{
+    uint32_t i, j;
+
+    j = context->count[0];
+    if ((context->count[0] += len << 3) < j)
+        context->count[1]++;
+    context->count[1] += (len>>29);
+    j = (j >> 3) & 63;
+    if ((j + len) > 63) {
+        memcpy(&context->buffer[j], data, (i = 64-j));
+        SHA1Transform(context->state, context->buffer);
+        for ( ; i + 63 < len; i += 64) {
+            SHA1Transform(context->state, &data[i]);
+        }
+        j = 0;
+    }
+    else i = 0;
+    memcpy(&context->buffer[j], &data[i], len - i);
+}
+
+
+/* Add padding and return the message digest. */
+
+void SHA1Final(unsigned char digest[20], SHA1_CTX* context)
+{
+    unsigned i;
+    unsigned char finalcount[8];
+    unsigned char c;
+
+#if 0	/* untested "improvement" by DHR */
+    /* Convert context->count to a sequence of bytes
+     * in finalcount.  Second element first, but
+     * big-endian order within element.
+     * But we do it all backwards.
+     */
+    unsigned char *fcp = &finalcount[8];
+
+    for (i = 0; i < 2; i++)
+       {
+        uint32_t t = context->count[i];
+        int j;
+
+        for (j = 0; j < 4; t >>= 8, j++)
+	          *--fcp = (unsigned char) t;
+    }
+#else
+    for (i = 0; i < 8; i++) {
+        finalcount[i] = (unsigned char)((context->count[(i >= 4 ? 0 : 1)]
+         >> ((3-(i & 3)) * 8) ) & 255);  /* Endian independent */
+    }
+#endif
+    c = 0200;
+    SHA1Update(context, &c, 1);
+    while ((context->count[0] & 504) != 448) {
+	c = 0000;
+        SHA1Update(context, &c, 1);
+    }
+    SHA1Update(context, finalcount, 8);  /* Should cause a SHA1Transform() */
+    for (i = 0; i < 20; i++) {
+        digest[i] = (unsigned char)
+         ((context->state[i>>2] >> ((3-(i & 3)) * 8) ) & 255);
+    }
+    /* Wipe variables */
+    memset(context, '\0', sizeof(*context));
+    memset(&finalcount, '\0', sizeof(finalcount));
+}
+/* ================ end of sha1.c ================ */
+
+
+#endif

src/libsha1/libsha1.h

@@ -0,0 +1,21 @@
+/* ================ sha1.h ================ */
+/*
+SHA-1 in C
+By Steve Reid <steve@edmweb.com>
+100% Public Domain
+*/
+
+#if !defined(ESP8266) && !defined(ESP32)
+
+typedef struct {
+    uint32_t state[5];
+    uint32_t count[2];
+    unsigned char buffer[64];
+} SHA1_CTX;
+
+void SHA1Transform(uint32_t state[5], const unsigned char buffer[64]);
+void SHA1Init(SHA1_CTX* context);
+void SHA1Update(SHA1_CTX* context, const unsigned char* data, uint32_t len);
+void SHA1Final(unsigned char digest[20], SHA1_CTX* context);
+
+#endif

tests/webSocket.html

@@ -2,11 +2,17 @@
 <head>
 
 <script>
-var connection = new WebSocket('ws://10.11.2.2:81/test', ['arduino']);
+var connection = new WebSocket('ws://10.11.2.1:81/', ['arduino']);
 
 connection.onopen = function () {
 	connection.send('Message from Browser to ESP8266 yay its Working!! ' + new Date()); 
 	connection.send('ping');
+	
+/*	setInterval(function() {
+		connection.send('Time: ' + new Date()); 
+	}, 20);
+*/
+connection.send('Time: ' + new Date()); 
 };
 
 connection.onerror = function (error) {
@@ -15,16 +21,29 @@ connection.onerror = function (error) {
 
 connection.onmessage = function (e) {
 	console.log('Server: ', e.data);
+	connection.send('Time: ' + new Date()); 
 };
 
-setInterval(function() {
-	connection.send('Time: ' + new Date()); 
-}, 1000);
+function sendRGB() {
+	var r = parseInt(document.getElementById('r').value).toString(16);
+	var g = parseInt(document.getElementById('g').value).toString(16);
+	var b = parseInt(document.getElementById('b').value).toString(16);
+	if(r.length < 2) { r = '0' + r; }
+	if(g.length < 2) { g = '0' + g; }
+	if(b.length < 2) { b = '0' + b; }
+	var rgb = '#'+r+g+b;
+	console.log('RGB: ' + rgb);
+	connection.send(rgb); 
+}
 
 </script>
 
 </head>
 <body>
-Test Websocket.
+LED Control:<br/>
+<br/>
+R: <input id="r" type="range" min="0" max="255" step="1" onchange="sendRGB();" /><br/>
+G: <input id="g" type="range" min="0" max="255" step="1" onchange="sendRGB();" /><br/>
+B: <input id="b" type="range" min="0" max="255" step="1" onchange="sendRGB();" /><br/>
 </body>
 </html>

tests/webSocketServer/index.js

@@ -7,7 +7,7 @@ var server = http.createServer(function(request, response) {
     response.writeHead(404);
     response.end();
 });
-server.listen(81, function() {
+server.listen(8011, function() {
     console.log((new Date()) + ' Server is listening on port 8011');
 });
  
@@ -41,11 +41,11 @@ wsServer.on('request', function(request) {
 	connection.on('message', function(message) {
         if (message.type === 'utf8') {
             console.log('Received Message: ' + message.utf8Data);
-            connection.sendUTF(message.utf8Data);
+           // connection.sendUTF(message.utf8Data);
         }
         else if (message.type === 'binary') {
             console.log('Received Binary Message of ' + message.binaryData.length + ' bytes');
-            connection.sendBytes(message.binaryData);
+           //connection.sendBytes(message.binaryData);
         }
     });
     
@@ -54,4 +54,4 @@ wsServer.on('request', function(request) {
     });
 	
 	connection.sendUTF("Hallo Client!");
-});
+});

travis/common.sh

@@ -0,0 +1,159 @@
+#!/bin/bash
+set -e
+
+function build_sketches()
+{
+    local arduino=$1
+    local srcpath=$2
+    local platform=$3
+    local sketches=$(find $srcpath -name *.ino)
+    for sketch in $sketches; do
+        local sketchdir=$(dirname $sketch)
+        if [[ -f "$sketchdir/.$platform.skip" ]]; then
+            echo -e "\n\n ------------ Skipping $sketch ------------ \n\n";
+            continue
+        fi
+        echo -e "\n\n ------------ Building $sketch ------------ \n\n";
+        $arduino --verify $sketch;
+        local result=$?
+        if [ $result -ne 0 ]; then
+            echo "Build failed ($sketch) build verbose..."
+            $arduino --verify --verbose --preserve-temp-files $sketch
+            result=$?
+        fi
+        if [ $result -ne 0 ]; then
+            echo "Build failed ($1) $sketch"
+            return $result
+        fi
+    done
+}
+
+function build_sketch_cli()
+{
+    local sketch=$1
+    local board=$2
+    arduino-cli --log --log-level info compile -b "$board" "$sketch"
+    result=$?
+    if [ $result -ne 0 ]; then
+        echo "Build failed ($sketch) build verbose..."
+        arduino-cli --log --log-level debug compile -b "$board" "$sketch"
+        result=$?
+    fi
+    if [ $result -ne 0 ]; then
+        echo "Build failed ($1) $sketch"
+        return $result
+    fi
+}
+
+function build_sketch()
+{
+    local arduino=$1
+    local sketch=$2
+    $arduino --verify --verbose $sketch;
+    local result=$?
+    if [ $result -ne 0 ]; then
+        echo "Build failed ($sketch) build verbose..."
+        $arduino --verify --verbose --preserve-temp-files $sketch
+        result=$?
+    fi
+    if [ $result -ne 0 ]; then
+        echo "Build failed ($1) $sketch"
+        return $result
+    fi
+}
+
+function get_sketches_json()
+{
+    local arduino=$1
+    local srcpath=$2
+    local platform=$3
+    local sketches=($(find $srcpath -name *.ino))
+    echo -en "["
+    for sketch in "${sketches[@]}" ; do
+        local sketchdir=$(dirname $sketch)
+        if [[ -f "$sketchdir/.$platform.skip" ]]; then
+            continue
+        fi
+        echo -en "\"$sketch\""
+        if [[ $sketch != ${sketches[-1]} ]] ; then
+            echo -en ","
+        fi
+
+    done
+    echo -en "]"
+}
+
+function get_sketches_json_matrix()
+{
+    local arduino=$1
+    local srcpath=$2
+    local platform=$3
+    local cliversion=$4
+    local board=$5
+    local sketches=($(find $srcpath -name *.ino))
+    for sketch in "${sketches[@]}" ; do
+        local sketchdir=$(dirname $sketch)
+        local sketchname=$(basename $sketch)
+        if [[ -f "$sketchdir/.$platform.skip" ]]; then
+            continue
+        fi
+        echo -en "{\"name\":\"$sketchname\",\"board\":\"$board\",\"cliversion\":\"$cliversion\",\"cpu\":\"$platform\",\"sketch\":\"$sketch\"}"
+        if [[ $sketch != ${sketches[-1]} ]] ; then
+            echo -en ","
+        fi
+    done
+}
+
+function get_core_cli() {
+    export ARDUINO_BOARD_MANAGER_ADDITIONAL_URLS="https://arduino.esp8266.com/stable/package_esp8266com_index.json https://espressif.github.io/arduino-esp32/package_esp32_index.json https://github.com/earlephilhower/arduino-pico/releases/download/3.9.2/package_rp2040_index.json"
+    arduino-cli core update-index
+    arduino-cli core install esp8266:esp8266
+    arduino-cli core install esp32:esp32
+    arduino-cli core install rp2040:rp2040
+}
+
+function get_core()
+{
+    echo Setup core for $1
+
+    mkdir -p $HOME/arduino_ide/packages/hardware
+    cd $HOME/arduino_ide/packages/hardware
+
+    if [ "$1" = "esp8266" ] ; then
+        mkdir esp8266com
+        cd esp8266com
+        git clone --depth 1 https://github.com/esp8266/Arduino.git esp8266
+        cd esp8266/
+        git submodule update --init
+        rm -rf .git
+        cd tools
+        python get.py
+    fi
+
+    if [ "$1" = "esp32" ] ; then
+        mkdir espressif
+        cd espressif
+        git clone --depth 1 https://github.com/espressif/arduino-esp32.git esp32
+        cd esp32/
+        rm -rf .git
+        cd tools
+        python get.py
+    fi
+
+}
+
+function clone_library() {
+    local url=$1
+    echo clone $(basename $url)
+    mkdir -p $HOME/Arduino/libraries
+    cd $HOME/Arduino/libraries
+    git clone --depth 1 $url
+    rm -rf */.git
+    rm -rf */.github
+    rm -rf */examples
+}
+
+function hash_library_names() {
+    cd $HOME/Arduino/libraries
+    ls | sha1sum -z | cut -c1-5
+}

travis/version.py

@@ -0,0 +1,132 @@
+#!/usr/bin/python3
+
+import json
+import configparser
+import argparse
+import re
+import os
+import datetime
+
+travis_dir = os.path.dirname(os.path.abspath(__file__))
+base_dir = os.path.abspath(travis_dir + "/../")
+
+def write_header_file(version):
+    hvs = version.split('.')
+    intversion = int(hvs[0]) * 1000000 + int(hvs[1]) * 1000 + int(hvs[2])
+    now = datetime.datetime.now()
+
+    text = f'''/**
+ * @file WebSocketsVersion.h
+ * @date {now.strftime("%d.%m.%Y")}
+ * @author Markus Sattler
+ *
+ * Copyright (c) 2015 Markus Sattler. All rights reserved.
+ * This file is part of the WebSockets for Arduino.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+ *
+ */
+
+#ifndef WEBSOCKETSVERSION_H_
+#define WEBSOCKETSVERSION_H_
+
+#define WEBSOCKETS_VERSION "{version}"
+
+#define WEBSOCKETS_VERSION_MAJOR {hvs[0]}
+#define WEBSOCKETS_VERSION_MINOR {hvs[1]}
+#define WEBSOCKETS_VERSION_PATCH {hvs[2]}
+
+#define WEBSOCKETS_VERSION_INT {intversion}
+
+#endif /* WEBSOCKETSVERSION_H_ */
+'''
+    with open(f'{base_dir}/src/WebSocketsVersion.h', 'w') as f:
+        f.write(text)
+
+
+def get_library_properties_version():
+    library_properties = {}
+    with open(f'{base_dir}/library.properties', 'r') as f:
+        library_properties = configparser.ConfigParser()
+        library_properties.read_string('[root]\n' + f.read())
+    return library_properties['root']['version']
+
+
+def get_library_json_version():
+    library_json = {}
+    with open(f'{base_dir}/library.json', 'r') as f:
+        library_json = json.load(f)
+    return library_json['version']
+
+
+def get_header_versions():
+    data = {}
+    define = re.compile('^#define WEBSOCKETS_VERSION_?(.*) "?([0-9\.]*)"?$')
+    with open(f'{base_dir}/src/WebSocketsVersion.h', 'r') as f:
+        for line in f:
+            m = define.match(line)
+            if m:
+                name = m[1]
+                if name == "":
+                    name = "VERSION"
+                data[name] = m[2]
+    return data
+
+
+parser = argparse.ArgumentParser(description='Checks and update Version files')
+parser.add_argument(
+    '--update', action='store_true', default=False)
+parser.add_argument(
+    '--check', action='store_true', default=True)
+
+args = parser.parse_args()
+
+if args.update:
+    library_properties_version = get_library_properties_version()
+
+    with open(f'{base_dir}/library.json', 'r') as f:
+        library_json = json.load(f)
+
+    library_json['version'] = library_properties_version
+
+    with open(f'{base_dir}/library.json', 'w') as f:
+        json.dump(library_json, f, indent=4, sort_keys=True)
+
+    write_header_file(library_properties_version)
+
+
+library_json_version = get_library_json_version()
+library_properties_version = get_library_properties_version()
+header_version = get_header_versions()
+
+print("WebSocketsVersion.h", header_version)
+print(f"library.json: {library_json_version}")
+print(f"library.properties: {library_properties_version}")
+
+if args.check:
+    if library_json_version != library_properties_version or header_version['VERSION'] != library_properties_version:
+        raise Exception('versions did not match!')
+
+    hvs = header_version['VERSION'].split('.')
+    if header_version['MAJOR'] != hvs[0]:
+        raise Exception('header MAJOR version wrong!')
+    if header_version['MINOR'] != hvs[1]:
+        raise Exception('header MINOR version wrong!')
+    if header_version['PATCH'] != hvs[2]:
+        raise Exception('header PATCH version wrong!')
+
+    intversion = int(hvs[0]) * 1000000 + int(hvs[1]) * 1000 + int(hvs[2])
+    if int(header_version['INT']) != intversion:
+        raise Exception('header INT version wrong!')