Add and remove libs and components for Arduino Core 3 (#400)

* Add and remove libs and components for Arduino Core 3

* Add back NimBLE-Arduino in resources

lib/AsyncTCP-esphome/.github/dependabot.yml

@@ -0,0 +1,10 @@
+# Set update schedule for GitHub Actions
+
+version: 2
+updates:
+
+  - package-ecosystem: "github-actions"
+    directory: "/"
+    schedule:
+      # Check for updates to GitHub Actions every week
+      interval: "weekly"

lib/AsyncTCP-esphome/.github/stale.yml

@@ -0,0 +1,31 @@
+# Configuration for probot-stale - https://github.com/probot/stale
+
+daysUntilStale: 60
+daysUntilClose: 14
+limitPerRun: 30
+staleLabel: stale
+exemptLabels:
+  - pinned
+  - security
+  - "to be implemented"
+  - "for reference"
+  - "move to PR"
+  - "enhancement"
+
+only: issues
+onlyLabels: []
+exemptProjects: false
+exemptMilestones: false
+exemptAssignees: false
+
+markComment: >
+  [STALE_SET] This issue has been automatically marked as stale because it has not had
+  recent activity. It will be closed in 14 days if no further activity occurs. Thank you
+  for your contributions.
+
+unmarkComment: >
+  [STALE_CLR] This issue has been removed from the stale queue. Please ensure activity to keep it openin the future.
+
+closeComment: >
+  [STALE_DEL] This stale issue has been automatically closed. Thank you for your contributions.
+

lib/AsyncTCP-esphome/.github/workflows/push.yml

@@ -0,0 +1,29 @@
+name: Async TCP CI
+
+on:
+  push:
+    branches:
+  pull_request:
+
+jobs:
+
+  build-arduino:
+    name: Arduino on ${{ matrix.os }}
+    runs-on: ${{ matrix.os }}
+    strategy:
+      matrix:
+        os: [ubuntu-latest]
+    steps:
+      - uses: actions/checkout@v3
+      - uses: arduino/setup-arduino-cli@v1
+      - name: Download board
+        run: |
+          arduino-cli --config-file arduino-cli.yaml core update-index
+          arduino-cli --config-file arduino-cli.yaml board listall
+          arduino-cli --config-file arduino-cli.yaml core install esp32:esp32@2.0.2
+      - name: Compile Sketch
+        run: arduino-cli --config-file arduino-cli.yaml --library ./src/ compile --fqbn esp32:esp32:esp32 ./examples/ClientServer/Client/Client.ino
+      - name: Compile Sketch with IPv6
+        env:
+          LWIP_IPV6: true
+        run: arduino-cli --config-file arduino-cli.yaml --library ./src/ compile --fqbn esp32:esp32:esp32 ./examples/ClientServer/Client/Client.ino

lib/AsyncTCP-esphome/.gitignore

@@ -0,0 +1,2 @@
+
+.DS_Store

lib/AsyncTCP-esphome/.piopm

@@ -0,0 +1 @@
+{"type": "library", "name": "AsyncTCP-esphome", "version": "2.1.3", "spec": {"owner": "esphome", "id": 12172, "name": "AsyncTCP-esphome", "requirements": null, "uri": null}}

lib/AsyncTCP-esphome/.travis.yml

@@ -0,0 +1,34 @@
+sudo: false
+language: python
+os:
+  - linux
+
+git:
+  depth: false
+
+stages:
+  - build
+
+jobs:
+  include:
+
+    - name: "Arduino Build"
+      if: tag IS blank AND (type = pull_request OR (type = push AND branch = master))
+      stage: build
+      script: bash $TRAVIS_BUILD_DIR/.github/scripts/on-push.sh
+
+    - name: "PlatformIO Build"
+      if: tag IS blank AND (type = pull_request OR (type = push AND branch = master))
+      stage: build
+      script: bash $TRAVIS_BUILD_DIR/.github/scripts/on-push.sh 1 1
+
+notifications:
+  email:
+    on_success: change
+    on_failure: change
+  webhooks:
+    urls:
+      - https://webhooks.gitter.im/e/60e65d0c78ea0a920347
+    on_success: change  # options: [always|never|change] default: always
+    on_failure: always  # options: [always|never|change] default: always
+    on_start: false     # default: false

lib/AsyncTCP-esphome/CMakeLists.txt

@@ -0,0 +1,15 @@
+set(COMPONENT_SRCDIRS
+    "src"
+)
+
+set(COMPONENT_ADD_INCLUDEDIRS
+    "src"
+)
+
+set(COMPONENT_REQUIRES
+    "arduino-esp32"
+)
+
+register_component()
+
+target_compile_options(${COMPONENT_TARGET} PRIVATE -fno-rtti)

lib/AsyncTCP-esphome/Kconfig.projbuild

@@ -0,0 +1,30 @@
+menu "AsyncTCP Configuration"
+
+choice ASYNC_TCP_RUNNING_CORE
+    bool "Core on which AsyncTCP's thread is running"
+    default ASYNC_TCP_RUN_CORE1
+    help
+        Select on which core AsyncTCP is running
+
+    config ASYNC_TCP_RUN_CORE0
+        bool "CORE 0"
+    config ASYNC_TCP_RUN_CORE1
+        bool "CORE 1"
+    config ASYNC_TCP_RUN_NO_AFFINITY
+        bool "BOTH"
+
+endchoice
+
+config ASYNC_TCP_RUNNING_CORE
+    int
+    default 0 if ASYNC_TCP_RUN_CORE0
+    default 1 if ASYNC_TCP_RUN_CORE1
+    default -1 if ASYNC_TCP_RUN_NO_AFFINITY
+
+config ASYNC_TCP_USE_WDT
+    bool "Enable WDT for the AsyncTCP task"
+    default "y"
+    help
+        Enable WDT for the AsyncTCP task, so it will trigger if a handler is locking the thread.
+
+endmenu

lib/AsyncTCP-esphome/LICENSE

@@ -0,0 +1,165 @@
+                   GNU LESSER GENERAL PUBLIC LICENSE
+                       Version 3, 29 June 2007
+
+ Copyright (C) 2007 Free Software Foundation, Inc. <http://fsf.org/>
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+
+  This version of the GNU Lesser General Public License incorporates
+the terms and conditions of version 3 of the GNU General Public
+License, supplemented by the additional permissions listed below.
+
+  0. Additional Definitions.
+
+  As used herein, "this License" refers to version 3 of the GNU Lesser
+General Public License, and the "GNU GPL" refers to version 3 of the GNU
+General Public License.
+
+  "The Library" refers to a covered work governed by this License,
+other than an Application or a Combined Work as defined below.
+
+  An "Application" is any work that makes use of an interface provided
+by the Library, but which is not otherwise based on the Library.
+Defining a subclass of a class defined by the Library is deemed a mode
+of using an interface provided by the Library.
+
+  A "Combined Work" is a work produced by combining or linking an
+Application with the Library.  The particular version of the Library
+with which the Combined Work was made is also called the "Linked
+Version".
+
+  The "Minimal Corresponding Source" for a Combined Work means the
+Corresponding Source for the Combined Work, excluding any source code
+for portions of the Combined Work that, considered in isolation, are
+based on the Application, and not on the Linked Version.
+
+  The "Corresponding Application Code" for a Combined Work means the
+object code and/or source code for the Application, including any data
+and utility programs needed for reproducing the Combined Work from the
+Application, but excluding the System Libraries of the Combined Work.
+
+  1. Exception to Section 3 of the GNU GPL.
+
+  You may convey a covered work under sections 3 and 4 of this License
+without being bound by section 3 of the GNU GPL.
+
+  2. Conveying Modified Versions.
+
+  If you modify a copy of the Library, and, in your modifications, a
+facility refers to a function or data to be supplied by an Application
+that uses the facility (other than as an argument passed when the
+facility is invoked), then you may convey a copy of the modified
+version:
+
+   a) under this License, provided that you make a good faith effort to
+   ensure that, in the event an Application does not supply the
+   function or data, the facility still operates, and performs
+   whatever part of its purpose remains meaningful, or
+
+   b) under the GNU GPL, with none of the additional permissions of
+   this License applicable to that copy.
+
+  3. Object Code Incorporating Material from Library Header Files.
+
+  The object code form of an Application may incorporate material from
+a header file that is part of the Library.  You may convey such object
+code under terms of your choice, provided that, if the incorporated
+material is not limited to numerical parameters, data structure
+layouts and accessors, or small macros, inline functions and templates
+(ten or fewer lines in length), you do both of the following:
+
+   a) Give prominent notice with each copy of the object code that the
+   Library is used in it and that the Library and its use are
+   covered by this License.
+
+   b) Accompany the object code with a copy of the GNU GPL and this license
+   document.
+
+  4. Combined Works.
+
+  You may convey a Combined Work under terms of your choice that,
+taken together, effectively do not restrict modification of the
+portions of the Library contained in the Combined Work and reverse
+engineering for debugging such modifications, if you also do each of
+the following:
+
+   a) Give prominent notice with each copy of the Combined Work that
+   the Library is used in it and that the Library and its use are
+   covered by this License.
+
+   b) Accompany the Combined Work with a copy of the GNU GPL and this license
+   document.
+
+   c) For a Combined Work that displays copyright notices during
+   execution, include the copyright notice for the Library among
+   these notices, as well as a reference directing the user to the
+   copies of the GNU GPL and this license document.
+
+   d) Do one of the following:
+
+       0) Convey the Minimal Corresponding Source under the terms of this
+       License, and the Corresponding Application Code in a form
+       suitable for, and under terms that permit, the user to
+       recombine or relink the Application with a modified version of
+       the Linked Version to produce a modified Combined Work, in the
+       manner specified by section 6 of the GNU GPL for conveying
+       Corresponding Source.
+
+       1) Use a suitable shared library mechanism for linking with the
+       Library.  A suitable mechanism is one that (a) uses at run time
+       a copy of the Library already present on the user's computer
+       system, and (b) will operate properly with a modified version
+       of the Library that is interface-compatible with the Linked
+       Version.
+
+   e) Provide Installation Information, but only if you would otherwise
+   be required to provide such information under section 6 of the
+   GNU GPL, and only to the extent that such information is
+   necessary to install and execute a modified version of the
+   Combined Work produced by recombining or relinking the
+   Application with a modified version of the Linked Version. (If
+   you use option 4d0, the Installation Information must accompany
+   the Minimal Corresponding Source and Corresponding Application
+   Code. If you use option 4d1, you must provide the Installation
+   Information in the manner specified by section 6 of the GNU GPL
+   for conveying Corresponding Source.)
+
+  5. Combined Libraries.
+
+  You may place library facilities that are a work based on the
+Library side by side in a single library together with other library
+facilities that are not Applications and are not covered by this
+License, and convey such a combined library under terms of your
+choice, if you do both of the following:
+
+   a) Accompany the combined library with a copy of the same work based
+   on the Library, uncombined with any other library facilities,
+   conveyed under the terms of this License.
+
+   b) Give prominent notice with the combined library that part of it
+   is a work based on the Library, and explaining where to find the
+   accompanying uncombined form of the same work.
+
+  6. Revised Versions of the GNU Lesser General Public License.
+
+  The Free Software Foundation may publish revised and/or new versions
+of the GNU Lesser General Public License from time to time. Such new
+versions will be similar in spirit to the present version, but may
+differ in detail to address new problems or concerns.
+
+  Each version is given a distinguishing version number. If the
+Library as you received it specifies that a certain numbered version
+of the GNU Lesser General Public License "or any later version"
+applies to it, you have the option of following the terms and
+conditions either of that published version or of any later version
+published by the Free Software Foundation. If the Library as you
+received it does not specify a version number of the GNU Lesser
+General Public License, you may choose any version of the GNU Lesser
+General Public License ever published by the Free Software Foundation.
+
+  If the Library as you received it specifies that a proxy can decide
+whether future versions of the GNU Lesser General Public License shall
+apply, that proxy's public statement of acceptance of any version is
+permanent authorization for you to choose that version for the
+Library.

lib/AsyncTCP-esphome/README.md

@@ -0,0 +1,12 @@
+# AsyncTCP
+![Build Status](https://github.com/esphome/AsyncTCP/actions/workflows/push.yml/badge.svg)
+A fork of the [AsyncTCP](https://github.com/me-no-dev/AsyncTCP) library by [@me-no-dev](https://github.com/me-no-dev) for [ESPHome](https://esphome.io).
+
+### Async TCP Library for ESP32 Arduino
+
+This is a fully asynchronous TCP library, aimed at enabling trouble-free, multi-connection network environment for Espressif's ESP32 MCUs.
+
+This library is the base for [ESPAsyncWebServer](https://github.com/me-no-dev/ESPAsyncWebServer)
+
+## AsyncClient and AsyncServer
+The base classes on which everything else is built. They expose all possible scenarios, but are really raw and require more skills to use.

lib/AsyncTCP-esphome/arduino-cli.yaml

@@ -0,0 +1,25 @@
+board_manager:
+  additional_urls:
+    - https://espressif.github.io/arduino-esp32/package_esp32_index.json
+directories:
+  builtin.libraries: ./src/
+build_cache:
+  compilations_before_purge: 10
+  ttl: 720h0m0s
+daemon:
+  port: "50051"
+library:
+  enable_unsafe_install: false
+logging:
+  file: ""
+  format: text
+  level: info
+metrics:
+  addr: :9090
+  enabled: true
+output:
+  no_color: false
+sketch:
+  always_export_binaries: false
+updater:
+  enable_notification: true

lib/AsyncTCP-esphome/component.mk

@@ -0,0 +1,3 @@
+COMPONENT_ADD_INCLUDEDIRS := src
+COMPONENT_SRCDIRS := src
+CXXFLAGS += -fno-rtti

lib/AsyncTCP-esphome/examples/ClientServer/Client/Client.ino

@@ -0,0 +1,42 @@
+#include <AsyncTCP.h>
+
+#include "config.h"
+
+static void replyToServer(void* arg) {
+	AsyncClient* client = reinterpret_cast<AsyncClient*>(arg);
+
+	// send reply
+	if (client->space() > 32 && client->canSend()) {
+		char message[32];
+		client->add(message, strlen(message));
+		client->send();
+	}
+}
+
+/* event callbacks */
+static void handleData(void* arg, AsyncClient* client, void *data, size_t len) {
+	Serial.printf("\n data received from %s \n", client->remoteIP().toString().c_str());
+	Serial.write((uint8_t*)data, len);
+
+}
+
+void onConnect(void* arg, AsyncClient* client) {
+	Serial.printf("\n client has been connected to %s on port %d \n", SERVER_HOST_NAME, TCP_PORT);
+	replyToServer(client);
+}
+
+
+void setup() {
+	Serial.begin(115200);
+	delay(20);
+
+	AsyncClient* client = new AsyncClient;
+	client->onData(&handleData, client);
+	client->onConnect(&onConnect, client);
+	client->connect(SERVER_HOST_NAME, TCP_PORT);
+
+}
+
+void loop() {
+
+}

lib/AsyncTCP-esphome/examples/ClientServer/Client/config.h

@@ -0,0 +1,23 @@
+#ifndef CONFIG_H
+#define CONFIG_H
+
+/*
+ * This example demonstrate how to use asynchronous client & server APIs
+ * in order to establish tcp socket connections in client server manner.
+ * server is running (on port 7050) on one ESP, acts as AP, and other clients running on
+ * remaining ESPs acts as STAs. after connection establishment between server and clients
+ * there is a simple message transfer in every 2s. clients connect to server via it's host name
+ * (in this case 'esp_server') with help of DNS service running on server side.
+ *
+ * Note: default MSS for ESPAsyncTCP is 536 byte and defualt ACK timeout is 5s.
+*/
+
+#define SSID "ESP-TEST"
+#define PASSWORD "123456789"
+
+#define SERVER_HOST_NAME "esp_server"
+
+#define TCP_PORT 7050
+#define DNS_PORT 53
+
+#endif // CONFIG_H

lib/AsyncTCP-esphome/library.json

@@ -0,0 +1,23 @@
+{
+  "name": "AsyncTCP-esphome",
+  "description": "Asynchronous TCP Library for ESP32",
+  "keywords": "async,tcp",
+  "authors": {
+    "name": "Hristo Gochkov",
+    "maintainer": true
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/esphome/AsyncTCP.git"
+  },
+  "version": "2.1.3",
+  "license": "LGPL-3.0",
+  "frameworks": "arduino",
+  "platforms": [
+    "espressif32",
+    "libretiny"
+  ],
+  "build": {
+    "libCompatMode": 2
+  }
+}

lib/AsyncTCP-esphome/src/AsyncTCP.h

@@ -0,0 +1,247 @@
+/*
+  Asynchronous TCP library for Espressif MCUs
+
+  Copyright (c) 2016 Hristo Gochkov. All rights reserved.
+  This file is part of the esp8266 core for Arduino environment.
+
+  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 ASYNCTCP_H_
+#define ASYNCTCP_H_
+
+#include "IPAddress.h"
+#include "IPv6Address.h"
+#include <functional>
+#include "lwip/ip_addr.h"
+#include "lwip/ip6_addr.h"
+
+#ifndef LIBRETINY
+#include "sdkconfig.h"
+extern "C" {
+    #include "freertos/semphr.h"
+    #include "lwip/pbuf.h"
+}
+#else
+extern "C" {
+    #include <semphr.h>
+    #include <lwip/pbuf.h>
+}
+#define CONFIG_ASYNC_TCP_RUNNING_CORE -1 //any available core
+#define CONFIG_ASYNC_TCP_USE_WDT 0
+#endif
+
+//If core is not defined, then we are running in Arduino or PIO
+#ifndef CONFIG_ASYNC_TCP_RUNNING_CORE
+#define CONFIG_ASYNC_TCP_RUNNING_CORE -1 //any available core
+#define CONFIG_ASYNC_TCP_USE_WDT 1 //if enabled, adds between 33us and 200us per event
+#endif
+
+#ifndef CONFIG_ASYNC_TCP_STACK_SIZE
+#define CONFIG_ASYNC_TCP_STACK_SIZE 8192 * 2
+#endif
+
+class AsyncClient;
+
+#define ASYNC_MAX_ACK_TIME 5000
+#define ASYNC_WRITE_FLAG_COPY 0x01 //will allocate new buffer to hold the data while sending (else will hold reference to the data given)
+#define ASYNC_WRITE_FLAG_MORE 0x02 //will not send PSH flag, meaning that there should be more data to be sent before the application should react.
+
+typedef std::function<void(void*, AsyncClient*)> AcConnectHandler;
+typedef std::function<void(void*, AsyncClient*, size_t len, uint32_t time)> AcAckHandler;
+typedef std::function<void(void*, AsyncClient*, int8_t error)> AcErrorHandler;
+typedef std::function<void(void*, AsyncClient*, void *data, size_t len)> AcDataHandler;
+typedef std::function<void(void*, AsyncClient*, struct pbuf *pb)> AcPacketHandler;
+typedef std::function<void(void*, AsyncClient*, uint32_t time)> AcTimeoutHandler;
+
+struct tcp_pcb;
+struct ip_addr;
+
+class AsyncClient {
+  public:
+    AsyncClient(tcp_pcb* pcb = 0);
+    ~AsyncClient();
+
+    AsyncClient & operator=(const AsyncClient &other);
+    AsyncClient & operator+=(const AsyncClient &other);
+
+    bool operator==(const AsyncClient &other);
+
+    bool operator!=(const AsyncClient &other) {
+      return !(*this == other);
+    }
+    bool connect(IPAddress ip, uint16_t port);
+    bool connect(IPv6Address ip, uint16_t port);
+    bool connect(const char *host, uint16_t port);
+    void close(bool now = false);
+    void stop();
+    int8_t abort();
+    bool free();
+
+    bool canSend();//ack is not pending
+    size_t space();//space available in the TCP window
+    size_t add(const char* data, size_t size, uint8_t apiflags=ASYNC_WRITE_FLAG_COPY);//add for sending
+    bool send();//send all data added with the method above
+
+    //write equals add()+send()
+    size_t write(const char* data);
+    size_t write(const char* data, size_t size, uint8_t apiflags=ASYNC_WRITE_FLAG_COPY); //only when canSend() == true
+
+    uint8_t state();
+    bool connecting();
+    bool connected();
+    bool disconnecting();
+    bool disconnected();
+    bool freeable();//disconnected or disconnecting
+
+    uint16_t getMss();
+
+    uint32_t getRxTimeout();
+    void setRxTimeout(uint32_t timeout);//no RX data timeout for the connection in seconds
+
+    uint32_t getAckTimeout();
+    void setAckTimeout(uint32_t timeout);//no ACK timeout for the last sent packet in milliseconds
+
+    void setNoDelay(bool nodelay);
+    bool getNoDelay();
+
+    uint32_t getRemoteAddress();
+    uint16_t getRemotePort();
+    uint32_t getLocalAddress();
+    uint16_t getLocalPort();
+#if LWIP_IPV6
+    ip6_addr_t getRemoteAddress6();
+    ip6_addr_t getLocalAddress6();
+    IPv6Address remoteIP6();
+    IPv6Address localIP6();
+#endif
+
+    //compatibility
+    IPAddress remoteIP();
+    uint16_t remotePort();
+    IPAddress localIP();
+    uint16_t localPort();
+
+    void onConnect(AcConnectHandler cb, void* arg = 0);     //on successful connect
+    void onDisconnect(AcConnectHandler cb, void* arg = 0);  //disconnected
+    void onAck(AcAckHandler cb, void* arg = 0);             //ack received
+    void onError(AcErrorHandler cb, void* arg = 0);         //unsuccessful connect or error
+    void onData(AcDataHandler cb, void* arg = 0);           //data received (called if onPacket is not used)
+    void onPacket(AcPacketHandler cb, void* arg = 0);       //data received
+    void onTimeout(AcTimeoutHandler cb, void* arg = 0);     //ack timeout
+    void onPoll(AcConnectHandler cb, void* arg = 0);        //every 125ms when connected
+
+    void ackPacket(struct pbuf * pb);//ack pbuf from onPacket
+    size_t ack(size_t len); //ack data that you have not acked using the method below
+    void ackLater(){ _ack_pcb = false; } //will not ack the current packet. Call from onData
+
+    const char * errorToString(int8_t error);
+    const char * stateToString();
+
+    //Do not use any of the functions below!
+    static int8_t _s_poll(void *arg, struct tcp_pcb *tpcb);
+    static int8_t _s_recv(void *arg, struct tcp_pcb *tpcb, struct pbuf *pb, int8_t err);
+    static int8_t _s_fin(void *arg, struct tcp_pcb *tpcb, int8_t err);
+    static int8_t _s_lwip_fin(void *arg, struct tcp_pcb *tpcb, int8_t err);
+    static void _s_error(void *arg, int8_t err);
+    static int8_t _s_sent(void *arg, struct tcp_pcb *tpcb, uint16_t len);
+    static int8_t _s_connected(void* arg, void* tpcb, int8_t err);
+    static void _s_dns_found(const char *name, struct ip_addr *ipaddr, void *arg);
+
+    int8_t _recv(tcp_pcb* pcb, pbuf* pb, int8_t err);
+    tcp_pcb * pcb(){ return _pcb; }
+
+  protected:
+    bool _connect(ip_addr_t addr, uint16_t port);
+
+    tcp_pcb* _pcb;
+    int8_t  _closed_slot;
+
+    AcConnectHandler _connect_cb;
+    void* _connect_cb_arg;
+    AcConnectHandler _discard_cb;
+    void* _discard_cb_arg;
+    AcAckHandler _sent_cb;
+    void* _sent_cb_arg;
+    AcErrorHandler _error_cb;
+    void* _error_cb_arg;
+    AcDataHandler _recv_cb;
+    void* _recv_cb_arg;
+    AcPacketHandler _pb_cb;
+    void* _pb_cb_arg;
+    AcTimeoutHandler _timeout_cb;
+    void* _timeout_cb_arg;
+    AcConnectHandler _poll_cb;
+    void* _poll_cb_arg;
+
+    bool _ack_pcb;
+    uint32_t _tx_last_packet;
+    uint32_t _rx_ack_len;
+    uint32_t _rx_last_packet;
+    uint32_t _rx_timeout;
+    uint32_t _rx_last_ack;
+    uint32_t _ack_timeout;
+    uint16_t _connect_port;
+
+    int8_t _close();
+    void _free_closed_slot();
+    void _allocate_closed_slot();
+    int8_t _connected(void* pcb, int8_t err);
+    void _error(int8_t err);
+    int8_t _poll(tcp_pcb* pcb);
+    int8_t _sent(tcp_pcb* pcb, uint16_t len);
+    int8_t _fin(tcp_pcb* pcb, int8_t err);
+    int8_t _lwip_fin(tcp_pcb* pcb, int8_t err);
+    void _dns_found(struct ip_addr *ipaddr);
+
+  public:
+    AsyncClient* prev;
+    AsyncClient* next;
+};
+
+class AsyncServer {
+  public:
+    AsyncServer(IPAddress addr, uint16_t port);
+    AsyncServer(IPv6Address addr, uint16_t port);
+    AsyncServer(uint16_t port);
+    ~AsyncServer();
+    void onClient(AcConnectHandler cb, void* arg);
+    void begin();
+    void end();
+    void setNoDelay(bool nodelay);
+    bool getNoDelay();
+    uint8_t status();
+
+    //Do not use any of the functions below!
+    static int8_t _s_accept(void *arg, tcp_pcb* newpcb, int8_t err);
+    static int8_t _s_accepted(void *arg, AsyncClient* client);
+
+  protected:
+    uint16_t _port;
+    bool _bind4 = false;
+    bool _bind6 = false;
+    IPAddress _addr;
+    IPv6Address _addr6;
+    bool _noDelay;
+    tcp_pcb* _pcb;
+    AcConnectHandler _connect_cb;
+    void* _connect_cb_arg;
+
+    int8_t _accept(tcp_pcb* newpcb, int8_t err);
+    int8_t _accepted(AsyncClient* client);
+};
+
+
+#endif /* ASYNCTCP_H_ */

lib/AsyncTCP/src/IPv6Address.cpp

@@ -0,0 +1,90 @@
+/*
+ IPv6Address.cpp - Base class that provides IPv6Address
+ Copyright (c) 2011 Adrian McEwen.  All right reserved.
+
+ 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
+ */
+
+#include <Arduino.h>
+#include <IPv6Address.h>
+#include <Print.h>
+
+IPv6Address::IPv6Address()
+{
+    memset(_address.bytes, 0, sizeof(_address.bytes));
+}
+
+IPv6Address::IPv6Address(const uint8_t *address)
+{
+    memcpy(_address.bytes, address, sizeof(_address.bytes));
+}
+
+IPv6Address::IPv6Address(const uint32_t *address)
+{
+    memcpy(_address.bytes, (const uint8_t *)address, sizeof(_address.bytes));
+}
+
+IPv6Address& IPv6Address::operator=(const uint8_t *address)
+{
+    memcpy(_address.bytes, address, sizeof(_address.bytes));
+    return *this;
+}
+
+bool IPv6Address::operator==(const uint8_t* addr) const
+{
+    return memcmp(addr, _address.bytes, sizeof(_address.bytes)) == 0;
+}
+
+size_t IPv6Address::printTo(Print& p) const
+{
+    size_t n = 0;
+    for(int i = 0; i < 16; i+=2) {
+        if(i){
+            n += p.print(':');
+        }
+        n += p.printf("%02x", _address.bytes[i]);
+        n += p.printf("%02x", _address.bytes[i+1]);
+
+    }
+    return n;
+}
+
+String IPv6Address::toString() const
+{
+    char szRet[40];
+    sprintf(szRet,"%02x%02x:%02x%02x:%02x%02x:%02x%02x:%02x%02x:%02x%02x:%02x%02x:%02x%02x",
+            _address.bytes[0], _address.bytes[1], _address.bytes[2], _address.bytes[3],
+            _address.bytes[4], _address.bytes[5], _address.bytes[6], _address.bytes[7],
+            _address.bytes[8], _address.bytes[9], _address.bytes[10], _address.bytes[11],
+            _address.bytes[12], _address.bytes[13], _address.bytes[14], _address.bytes[15]);
+    return String(szRet);
+}
+
+bool IPv6Address::fromString(const char *address)
+{
+    //format 0011:2233:4455:6677:8899:aabb:ccdd:eeff
+    if(strlen(address) != 39){
+        return false;
+    }
+    char * pos = (char *)address;
+    size_t i = 0;
+    for(i = 0; i < 16; i+=2) {
+        if(!sscanf(pos, "%2hhx", &_address.bytes[i]) || !sscanf(pos+2, "%2hhx", &_address.bytes[i+1])){
+            return false;
+        }
+        pos += 5;
+    }
+    return true;
+}

lib/AsyncTCP/src/IPv6Address.h

@@ -0,0 +1,94 @@
+/*
+ IPv6Address.h - Base class that provides IPv6Address
+ Copyright (c) 2011 Adrian McEwen.  All right reserved.
+
+ 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 IPv6Address_h
+#define IPv6Address_h
+
+#include <stdint.h>
+#include <WString.h>
+#include <Printable.h>
+
+// A class to make it easier to handle and pass around IP addresses
+
+class IPv6Address: public Printable
+{
+private:
+    union {
+        uint8_t bytes[16];  // IPv4 address
+        uint32_t dword[4];
+    } _address;
+
+    // Access the raw byte array containing the address.  Because this returns a pointer
+    // to the internal structure rather than a copy of the address this function should only
+    // be used when you know that the usage of the returned uint8_t* will be transient and not
+    // stored.
+    uint8_t* raw_address()
+    {
+        return _address.bytes;
+    }
+
+public:
+    // Constructors
+    IPv6Address();
+    IPv6Address(const uint8_t *address);
+    IPv6Address(const uint32_t *address);
+    virtual ~IPv6Address() {}
+
+    bool fromString(const char *address);
+    bool fromString(const String &address) { return fromString(address.c_str()); }
+
+    operator const uint8_t*() const
+    {
+        return _address.bytes;
+    }
+    operator const uint32_t*() const
+    {
+        return _address.dword;
+    }
+    bool operator==(const IPv6Address& addr) const
+    {
+        return (_address.dword[0] == addr._address.dword[0])
+            && (_address.dword[1] == addr._address.dword[1])
+            && (_address.dword[2] == addr._address.dword[2])
+            && (_address.dword[3] == addr._address.dword[3]);
+    }
+    bool operator==(const uint8_t* addr) const;
+
+    // Overloaded index operator to allow getting and setting individual octets of the address
+    uint8_t operator[](int index) const
+    {
+        return _address.bytes[index];
+    }
+    uint8_t& operator[](int index)
+    {
+        return _address.bytes[index];
+    }
+
+    // Overloaded copy operators to allow initialisation of IPv6Address objects from other types
+    IPv6Address& operator=(const uint8_t *address);
+
+    virtual size_t printTo(Print& p) const;
+    String toString() const;
+
+    friend class UDP;
+    friend class Client;
+    friend class Server;
+};
+
+#endif

lib/CRC16/.github/workflows/main.yml

@@ -0,0 +1,11 @@
+name: Arduino_CI
+
+on: [push, pull_request]
+
+jobs:
+  arduino_ci:
+    name: "Arduino CI - OS(Ubuntu)"
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v2
+      - uses: Arduino-CI/action@master

lib/CRC16/library.json

@@ -0,0 +1,18 @@
+{
+    "name": "Crc16",
+    "keywords": "CRC, crc, crc16",
+    "description": "Arduino Library for CRC-16 checks",
+    "authors": [
+        {
+            "name": "Vincenzo Mennella",
+            "maintainer": true
+        }
+    ],
+    "repository": {
+        "type": "git",
+        "url": "https://https://github.com/vinmenn/Crc16.git"
+    },
+    "version": "0.1.2",
+    "frameworks": "arduino",
+    "platforms": "*"
+}

lib/CRC16/library.properties

@@ -0,0 +1,11 @@
+name=Crc16
+version=0.1.2
+author=Vincenzo Mennella
+maintainer=Hugo Arganda <hugo.arganda@gmail.com>
+sentence=CRC16 Library
+paragraph=CRC16 Library
+category=Data Processing
+url=https://github.com/vinmenn/Crc16.git
+architectures=*
+includes=Crc16.h
+depends=

lib/CRC16/src/Crc16.cpp

@@ -0,0 +1,163 @@
+#include "Crc16.h"
+
+//---------------------------------------------------
+// Initialize crc calculation
+//---------------------------------------------------
+void Crc16::clearCrc()
+{
+    _crc = _xorIn;
+}
+
+//---------------------------------------------------
+// Update crc with new data
+//---------------------------------------------------
+void Crc16::updateCrc(uint8_t data)
+{
+    if (_reflectIn != 0)
+        data = (uint8_t)reflect(data);
+
+    int j = 0x80;
+
+    while (j > 0)
+    {
+        uint16_t bit = (uint16_t)(_crc & _msbMask);
+
+        _crc <<= 1;
+
+        if ((data & j) != 0)
+        {
+            bit = (uint16_t)(bit ^ _msbMask);
+        }
+
+        if (bit != 0)
+        {
+            _crc ^= _polynomial;
+        }
+
+        j >>= 1;
+    }
+}
+
+//---------------------------------------------------
+// Get final crc value
+//---------------------------------------------------
+uint16_t Crc16::getCrc()
+{
+    if (_reflectOut != 0)
+        _crc = (unsigned int)((reflect(_crc) ^ _xorOut) & _mask);
+
+    return _crc;
+}
+
+//---------------------------------------------------
+// Calculate generic crc code on data array
+// Examples of crc 16:
+// Kermit: 		width=16 poly=0x1021 init=0x0000 refin=true  refout=true  xorout=0x0000 check=0x2189
+// Modbus: 		width=16 poly=0x8005 init=0xffff refin=true  refout=true  xorout=0x0000 check=0x4b37
+// XModem: 		width=16 poly=0x1021 init=0x0000 refin=false refout=false xorout=0x0000 check=0x31c3
+// CCITT-False:	width=16 poly=0x1021 init=0xffff refin=false refout=false xorout=0x0000 check=0x29b1
+//---------------------------------------------------
+unsigned int Crc16::fastCrc(uint8_t data[], uint8_t start, uint16_t length, uint8_t reflectIn, uint8_t reflectOut, uint16_t polynomial, uint16_t xorIn, uint16_t xorOut, uint16_t msbMask, uint16_t mask)
+{
+    uint16_t crc = xorIn;
+
+    int j;
+    uint8_t c;
+    unsigned int bit;
+
+    if (length == 0)
+        return crc;
+
+    for (int i = start; i < (start + length); i++)
+    {
+        c = data[i];
+
+        if (reflectIn != 0)
+            c = (uint8_t)reflect(c);
+
+        j = 0x80;
+
+        while (j > 0)
+        {
+            bit = (unsigned int)(crc & msbMask);
+            crc <<= 1;
+
+            if ((c & j) != 0)
+            {
+                bit = (unsigned int)(bit ^ msbMask);
+            }
+
+            if (bit != 0)
+            {
+                crc ^= polynomial;
+            }
+
+            j >>= 1;
+        }
+    }
+
+    if (reflectOut != 0)
+        crc = (unsigned int)((reflect((uint16_t)crc) ^ xorOut) & mask);
+
+    return crc;
+}
+
+//-------------------------------------------------------
+// Reflects bit in a uint8_t
+//-------------------------------------------------------
+uint8_t Crc16::reflect(uint8_t data)
+{
+    const uint8_t bits = 8;
+    unsigned long reflection = 0x00000000;
+    // Reflect the data about the center bit.
+    for (uint8_t bit = 0; bit < bits; bit++)
+    {
+        // If the LSB bit is set, set the reflection of it.
+        if ((data & 0x01) != 0)
+        {
+            reflection |= (unsigned long)(1 << ((bits - 1) - bit));
+        }
+
+        data = (uint8_t)(data >> 1);
+    }
+
+    return reflection;
+}
+
+//-------------------------------------------------------
+// Reflects bit in a uint16_t
+//-------------------------------------------------------
+uint16_t Crc16::reflect(uint16_t data)
+{
+    const uint8_t bits = 16;
+    unsigned long reflection = 0x00000000;
+    // Reflect the data about the center bit.
+    for (uint8_t bit = 0; bit < bits; bit++)
+    {
+        // If the LSB bit is set, set the reflection of it.
+        if ((data & 0x01) != 0)
+        {
+            reflection |= (unsigned long)(1 << ((bits - 1) - bit));
+        }
+
+        data = (uint16_t)(data >> 1);
+    }
+
+    return reflection;
+}
+
+unsigned int Crc16::XModemCrc(uint8_t data[], uint8_t start, uint16_t length)
+{
+    //  XModem parameters: poly=0x1021 init=0x0000 refin=false refout=false xorout=0x0000
+    return fastCrc(data, start, length, false, false, 0x1021, 0x0000, 0x0000, 0x8000, 0xffff);
+}
+
+unsigned int Crc16::Mcrf4XX(uint8_t data[], uint8_t start, uint16_t length)
+{
+    return fastCrc(data, start, length, true, true, 0x1021, 0xffff, 0x0000, 0x8000, 0xffff);
+}
+
+unsigned int Crc16::Modbus(uint8_t data[], uint8_t start, uint16_t length)
+{
+    return fastCrc(data, start, length, true, true, 0x8005, 0xffff, 0x0000, 0x8000, 0xffff);
+}

lib/CRC16/src/Crc16.h

@@ -0,0 +1,94 @@
+//-------------------------------------------------------------------------------------
+// CRC16 support class
+// Based on various examples found on the web
+// Copyright (C) 2014 Vincenzo Mennella (see license.txt)
+// History
+//  0.1.0 31/05/2014:   First public code release
+//  0.1.1 17/12/2014:   Minor revision and commented code
+//  0.1.2 06/06/2019:   Fix reflect routine for 16 bit data
+//                      Added ModBus and Mcrf4XX inline functions
+//
+// License
+// "MIT Open Source Software License":
+// Permission is hereby granted, free of charge, to any person obtaining a copy of
+// this software and associated documentation files (the "Software"), to deal in the
+// Software without restriction, including without limitation the rights to use, copy,
+// modify, merge, publish, distribute, sublicense, and/or sell copies of the Software,
+// and to permit persons to whom the Software is furnished to do so, subject to
+// the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in all
+// copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+// FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+// COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+// IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+//-------------------------------------------------------------------------------------
+
+#ifndef CRC16_H
+#define CRC16_H
+#define LIBRARY_VERSION_CRC16_H "0.1.2"
+
+#if defined(ARDUINO) && ARDUINO >= 100
+#include "Arduino.h"
+#elif defined(ARDUINO)
+#include "WProgram.h"
+#else
+#include <cstdint>
+#endif
+
+class Crc16
+{
+private:
+    //Crc parameters
+    uint16_t _msbMask;
+    uint16_t _mask;
+    uint16_t _xorIn;
+    uint16_t _xorOut;
+    uint16_t _polynomial;
+    uint8_t _reflectIn;
+    uint8_t _reflectOut;
+    //Crc value
+    uint16_t _crc;
+    uint8_t reflect(uint8_t data);
+    uint16_t reflect(uint16_t data);
+
+public:
+    Crc16()
+    {
+        //Default to XModem parameters
+        _reflectIn = false;
+        _reflectOut = false;
+        _polynomial = 0x1021;
+        _xorIn = 0x0000;
+        _xorOut = 0x0000;
+        _msbMask = 0x8000;
+        _mask = 0xFFFF;
+        _crc = _xorIn;
+    }
+
+    Crc16(uint8_t reflectIn, uint8_t reflectOut, uint16_t polynomial, uint16_t xorIn, uint16_t xorOut, uint16_t msbMask, uint16_t mask)
+    {
+        _reflectIn = reflectIn;
+        _reflectOut = reflectOut;
+        _polynomial = polynomial;
+        _xorIn = xorIn;
+        _xorOut = xorOut;
+        _msbMask = msbMask;
+        _mask = mask;
+        _crc = _xorIn;
+    }
+
+    void clearCrc();
+    void updateCrc(uint8_t data);
+    uint16_t getCrc();
+    unsigned int fastCrc(uint8_t data[], uint8_t start, uint16_t length, uint8_t reflectIn, uint8_t reflectOut, uint16_t polynomial, uint16_t xorIn, uint16_t xorOut, uint16_t msbMask, uint16_t mask);
+    unsigned int XModemCrc(uint8_t data[], uint8_t start, uint16_t length);
+    unsigned int Mcrf4XX(uint8_t data[], uint8_t start, uint16_t length);
+    unsigned int Modbus(uint8_t data[], uint8_t start, uint16_t length);
+};
+
+#endif

lib/ESPAsyncTCP-esphome/.github/scripts/install-arduino-core-esp8266.sh

@@ -0,0 +1,29 @@
+#!/bin/bash
+
+echo "Installing ESP8266 Arduino Core ..."
+script_init_path="$PWD"
+mkdir -p "$ARDUINO_USR_PATH/hardware/esp8266com"
+cd "$ARDUINO_USR_PATH/hardware/esp8266com"
+
+echo "Installing Python Serial ..."
+pip install pyserial > /dev/null
+
+if [ "$OS_IS_WINDOWS" == "1" ]; then
+	echo "Installing Python Requests ..."
+	pip install requests > /dev/null
+fi
+
+echo "Cloning Core Repository ..."
+git clone https://github.com/esp8266/Arduino.git esp8266 > /dev/null 2>&1
+
+echo "Updating submodules ..."
+cd esp8266
+git submodule update --init --recursive > /dev/null 2>&1
+
+echo "Installing Platform Tools ..."
+cd tools
+python get.py > /dev/null
+cd $script_init_path
+
+echo "ESP8266 Arduino has been installed in '$ARDUINO_USR_PATH/hardware/esp8266com'"
+echo ""

lib/ESPAsyncTCP-esphome/.github/scripts/install-arduino-ide.sh

@@ -0,0 +1,220 @@
+#!/bin/bash
+
+#OSTYPE: 'linux-gnu', ARCH: 'x86_64' => linux64
+#OSTYPE: 'msys', ARCH: 'x86_64' => win32
+#OSTYPE: 'darwin18', ARCH: 'i386' => macos
+
+OSBITS=`arch`
+if [[ "$OSTYPE" == "linux"* ]]; then
+	export OS_IS_LINUX="1"
+	ARCHIVE_FORMAT="tar.xz"
+	if [[ "$OSBITS" == "i686" ]]; then
+		OS_NAME="linux32"
+	elif [[ "$OSBITS" == "x86_64" ]]; then
+		OS_NAME="linux64"
+	elif [[ "$OSBITS" == "armv7l" || "$OSBITS" == "aarch64" ]]; then
+		OS_NAME="linuxarm"
+	else
+		OS_NAME="$OSTYPE-$OSBITS"
+		echo "Unknown OS '$OS_NAME'"
+		exit 1
+	fi
+elif [[ "$OSTYPE" == "darwin"* ]]; then
+	export OS_IS_MACOS="1"
+	ARCHIVE_FORMAT="zip"
+	OS_NAME="macosx"
+elif [[ "$OSTYPE" == "cygwin" ]] || [[ "$OSTYPE" == "msys" ]] || [[ "$OSTYPE" == "win32" ]]; then
+	export OS_IS_WINDOWS="1"
+	ARCHIVE_FORMAT="zip"
+	OS_NAME="windows"
+else
+	OS_NAME="$OSTYPE-$OSBITS"
+	echo "Unknown OS '$OS_NAME'"
+	exit 1
+fi
+export OS_NAME
+
+ARDUINO_BUILD_DIR="$HOME/.arduino/build.tmp"
+ARDUINO_CACHE_DIR="$HOME/.arduino/cache.tmp"
+
+if [ "$OS_IS_MACOS" == "1" ]; then
+	export ARDUINO_IDE_PATH="/Applications/Arduino.app/Contents/Java"
+	export ARDUINO_USR_PATH="$HOME/Documents/Arduino"
+elif [ "$OS_IS_WINDOWS" == "1" ]; then
+	export ARDUINO_IDE_PATH="$HOME/arduino_ide"
+	export ARDUINO_USR_PATH="$HOME/Documents/Arduino"
+else
+	export ARDUINO_IDE_PATH="$HOME/arduino_ide"
+	export ARDUINO_USR_PATH="$HOME/Arduino"
+fi
+
+if [ ! -d "$ARDUINO_IDE_PATH" ]; then
+	echo "Installing Arduino IDE on $OS_NAME ..."
+	echo "Downloading 'arduino-nightly-$OS_NAME.$ARCHIVE_FORMAT' to 'arduino.$ARCHIVE_FORMAT' ..."
+	if [ "$OS_IS_LINUX" == "1" ]; then
+		wget -O "arduino.$ARCHIVE_FORMAT" "https://www.arduino.cc/download.php?f=/arduino-nightly-$OS_NAME.$ARCHIVE_FORMAT" > /dev/null 2>&1
+		echo "Extracting 'arduino.$ARCHIVE_FORMAT' ..."
+		tar xf "arduino.$ARCHIVE_FORMAT" > /dev/null
+		mv arduino-nightly "$ARDUINO_IDE_PATH"
+	else
+		curl -o "arduino.$ARCHIVE_FORMAT" -L "https://www.arduino.cc/download.php?f=/arduino-nightly-$OS_NAME.$ARCHIVE_FORMAT" > /dev/null 2>&1
+		echo "Extracting 'arduino.$ARCHIVE_FORMAT' ..."
+		unzip "arduino.$ARCHIVE_FORMAT" > /dev/null
+		if [ "$OS_IS_MACOS" == "1" ]; then
+			mv "Arduino.app" "/Applications/Arduino.app"
+		else
+			mv arduino-nightly "$ARDUINO_IDE_PATH"
+		fi
+	fi
+	rm -rf "arduino.$ARCHIVE_FORMAT"
+
+	mkdir -p "$ARDUINO_USR_PATH/libraries"
+	mkdir -p "$ARDUINO_USR_PATH/hardware"
+
+	echo "Arduino IDE Installed in '$ARDUINO_IDE_PATH'"
+	echo ""
+fi
+
+function build_sketch(){ # build_sketch <fqbn> <path-to-ino> [extra-options]
+    if [ "$#" -lt 2 ]; then
+		echo "ERROR: Illegal number of parameters"
+		echo "USAGE: build_sketch <fqbn> <path-to-ino> [extra-options]"
+		return 1
+	fi
+
+	local fqbn="$1"
+	local sketch="$2"
+	local xtra_opts="$3"
+	local win_opts=""
+	if [ "$OS_IS_WINDOWS" == "1" ]; then
+		local ctags_version=`ls "$ARDUINO_IDE_PATH/tools-builder/ctags/"`
+		local preprocessor_version=`ls "$ARDUINO_IDE_PATH/tools-builder/arduino-preprocessor/"`
+		win_opts="-prefs=runtime.tools.ctags.path=$ARDUINO_IDE_PATH/tools-builder/ctags/$ctags_version -prefs=runtime.tools.arduino-preprocessor.path=$ARDUINO_IDE_PATH/tools-builder/arduino-preprocessor/$preprocessor_version"
+	fi
+
+	echo ""
+	echo "Compiling '"$(basename "$sketch")"' ..."
+	mkdir -p "$ARDUINO_BUILD_DIR"
+	mkdir -p "$ARDUINO_CACHE_DIR"
+	$ARDUINO_IDE_PATH/arduino-builder -compile -logger=human -core-api-version=10810 \
+		-fqbn=$fqbn \
+		-warnings="all" \
+		-tools "$ARDUINO_IDE_PATH/tools-builder" \
+		-tools "$ARDUINO_IDE_PATH/tools" \
+		-built-in-libraries "$ARDUINO_IDE_PATH/libraries" \
+		-hardware "$ARDUINO_IDE_PATH/hardware" \
+		-hardware "$ARDUINO_USR_PATH/hardware" \
+		-libraries "$ARDUINO_USR_PATH/libraries" \
+		-build-cache "$ARDUINO_CACHE_DIR" \
+		-build-path "$ARDUINO_BUILD_DIR" \
+		$win_opts $xtra_opts "$sketch"
+}
+
+function count_sketches() # count_sketches <examples-path>
+{
+	local examples="$1"
+    rm -rf sketches.txt
+	if [ ! -d "$examples" ]; then
+		touch sketches.txt
+		return 0
+	fi
+    local sketches=$(find $examples -name *.ino)
+    local sketchnum=0
+    for sketch in $sketches; do
+        local sketchdir=$(dirname $sketch)
+        local sketchdirname=$(basename $sketchdir)
+        local sketchname=$(basename $sketch)
+        if [[ "${sketchdirname}.ino" != "$sketchname" ]]; then
+            continue
+        fi;
+        if [[ -f "$sketchdir/.test.skip" ]]; then
+            continue
+        fi
+        echo $sketch >> sketches.txt
+        sketchnum=$(($sketchnum + 1))
+    done
+    return $sketchnum
+}
+
+function build_sketches() # build_sketches <fqbn> <examples-path> <chunk> <total-chunks> [extra-options]
+{
+    local fqbn=$1
+    local examples=$2
+    local chunk_idex=$3
+    local chunks_num=$4
+    local xtra_opts=$5
+
+    if [ "$#" -lt 2 ]; then
+		echo "ERROR: Illegal number of parameters"
+		echo "USAGE: build_sketches <fqbn> <examples-path> [<chunk> <total-chunks>] [extra-options]"
+		return 1
+	fi
+
+    if [ "$#" -lt 4 ]; then
+		chunk_idex="0"
+		chunks_num="1"
+		xtra_opts=$3
+	fi
+
+	if [ "$chunks_num" -le 0 ]; then
+		echo "ERROR: Chunks count must be positive number"
+		return 1
+	fi
+	if [ "$chunk_idex" -ge "$chunks_num" ]; then
+		echo "ERROR: Chunk index must be less than chunks count"
+		return 1
+	fi
+
+	set +e
+    count_sketches "$examples"
+    local sketchcount=$?
+	set -e
+    local sketches=$(cat sketches.txt)
+    rm -rf sketches.txt
+
+    local chunk_size=$(( $sketchcount / $chunks_num ))
+    local all_chunks=$(( $chunks_num * $chunk_size ))
+    if [ "$all_chunks" -lt "$sketchcount" ]; then
+    	chunk_size=$(( $chunk_size + 1 ))
+    fi
+
+    local start_index=$(( $chunk_idex * $chunk_size ))
+    if [ "$sketchcount" -le "$start_index" ]; then
+    	echo "Skipping job"
+    	return 0
+    fi
+
+    local end_index=$(( $(( $chunk_idex + 1 )) * $chunk_size ))
+    if [ "$end_index" -gt "$sketchcount" ]; then
+    	end_index=$sketchcount
+    fi
+
+    local start_num=$(( $start_index + 1 ))
+    echo "Found $sketchcount Sketches";
+    echo "Chunk Count : $chunks_num"
+    echo "Chunk Size  : $chunk_size"
+    echo "Start Sketch: $start_num"
+    echo "End Sketch  : $end_index"
+
+    local sketchnum=0
+    for sketch in $sketches; do
+        local sketchdir=$(dirname $sketch)
+        local sketchdirname=$(basename $sketchdir)
+        local sketchname=$(basename $sketch)
+        if [ "${sketchdirname}.ino" != "$sketchname" ] \
+        || [ -f "$sketchdir/.test.skip" ]; then
+            continue
+        fi
+        sketchnum=$(($sketchnum + 1))
+        if [ "$sketchnum" -le "$start_index" ] \
+        || [ "$sketchnum" -gt "$end_index" ]; then
+        	continue
+        fi
+        build_sketch "$fqbn" "$sketch" "$xtra_opts"
+        local result=$?
+        if [ $result -ne 0 ]; then
+            return $result
+        fi
+    done
+    return 0
+}

lib/ESPAsyncTCP-esphome/.github/scripts/install-platformio.sh

@@ -0,0 +1,133 @@
+#!/bin/bash
+
+echo "Installing Python Wheel ..."
+pip install wheel > /dev/null 2>&1
+
+echo "Installing PlatformIO ..."
+pip install -U platformio > /dev/null 2>&1
+
+echo "PlatformIO has been installed"
+echo ""
+
+
+function build_pio_sketch(){ # build_pio_sketch <board> <path-to-ino>
+    if [ "$#" -lt 2 ]; then
+        echo "ERROR: Illegal number of parameters"
+        echo "USAGE: build_pio_sketch <board> <path-to-ino>"
+        return 1
+    fi
+
+	local board="$1"
+	local sketch="$2"
+	local sketch_dir=$(dirname "$sketch")
+	echo ""
+	echo "Compiling '"$(basename "$sketch")"' ..."
+	python -m platformio ci -l '.' --board "$board" "$sketch_dir" --project-option="board_build.partitions = huge_app.csv"
+}
+
+function count_sketches() # count_sketches <examples-path>
+{
+    local examples="$1"
+    rm -rf sketches.txt
+    if [ ! -d "$examples" ]; then
+        touch sketches.txt
+        return 0
+    fi
+    local sketches=$(find $examples -name *.ino)
+    local sketchnum=0
+    for sketch in $sketches; do
+        local sketchdir=$(dirname $sketch)
+        local sketchdirname=$(basename $sketchdir)
+        local sketchname=$(basename $sketch)
+        if [[ "${sketchdirname}.ino" != "$sketchname" ]]; then
+            continue
+        fi;
+        if [[ -f "$sketchdir/.test.skip" ]]; then
+            continue
+        fi
+        echo $sketch >> sketches.txt
+        sketchnum=$(($sketchnum + 1))
+    done
+    return $sketchnum
+}
+
+function build_pio_sketches() # build_pio_sketches <board> <examples-path> <chunk> <total-chunks>
+{
+    if [ "$#" -lt 2 ]; then
+        echo "ERROR: Illegal number of parameters"
+        echo "USAGE: build_pio_sketches <board> <examples-path> [<chunk> <total-chunks>]"
+        return 1
+    fi
+
+    local board=$1
+    local examples=$2
+    local chunk_idex=$3
+    local chunks_num=$4
+
+    if [ "$#" -lt 4 ]; then
+        chunk_idex="0"
+        chunks_num="1"
+    fi
+
+	if [ "$chunks_num" -le 0 ]; then
+		echo "ERROR: Chunks count must be positive number"
+		return 1
+	fi
+	if [ "$chunk_idex" -ge "$chunks_num" ]; then
+		echo "ERROR: Chunk index must be less than chunks count"
+		return 1
+	fi
+
+    set +e
+    count_sketches "$examples"
+    local sketchcount=$?
+    set -e
+    local sketches=$(cat sketches.txt)
+    rm -rf sketches.txt
+
+    local chunk_size=$(( $sketchcount / $chunks_num ))
+    local all_chunks=$(( $chunks_num * $chunk_size ))
+    if [ "$all_chunks" -lt "$sketchcount" ]; then
+    	chunk_size=$(( $chunk_size + 1 ))
+    fi
+
+    local start_index=$(( $chunk_idex * $chunk_size ))
+    if [ "$sketchcount" -le "$start_index" ]; then
+    	echo "Skipping job"
+    	return 0
+    fi
+
+    local end_index=$(( $(( $chunk_idex + 1 )) * $chunk_size ))
+    if [ "$end_index" -gt "$sketchcount" ]; then
+    	end_index=$sketchcount
+    fi
+
+    local start_num=$(( $start_index + 1 ))
+    echo "Found $sketchcount Sketches";
+    echo "Chunk Count : $chunks_num"
+    echo "Chunk Size  : $chunk_size"
+    echo "Start Sketch: $start_num"
+    echo "End Sketch  : $end_index"
+
+    local sketchnum=0
+    for sketch in $sketches; do
+        local sketchdir=$(dirname $sketch)
+        local sketchdirname=$(basename $sketchdir)
+        local sketchname=$(basename $sketch)
+        if [ "${sketchdirname}.ino" != "$sketchname" ] \
+        || [ -f "$sketchdir/.test.skip" ]; then
+            continue
+        fi
+        sketchnum=$(($sketchnum + 1))
+        if [ "$sketchnum" -le "$start_index" ] \
+        || [ "$sketchnum" -gt "$end_index" ]; then
+        	continue
+        fi
+        build_pio_sketch "$board" "$sketch"
+        local result=$?
+        if [ $result -ne 0 ]; then
+            return $result
+        fi
+    done
+    return 0
+}

lib/ESPAsyncTCP-esphome/.github/scripts/on-push.sh

@@ -0,0 +1,64 @@
+#!/bin/bash
+
+set -e
+
+if [ ! -z "$TRAVIS_BUILD_DIR" ]; then
+	export GITHUB_WORKSPACE="$TRAVIS_BUILD_DIR"
+	export GITHUB_REPOSITORY="$TRAVIS_REPO_SLUG"
+elif [ -z "$GITHUB_WORKSPACE" ]; then
+	export GITHUB_WORKSPACE="$PWD"
+	export GITHUB_REPOSITORY="me-no-dev/ESPAsyncTCP"
+fi
+
+CHUNK_INDEX=$1
+CHUNKS_CNT=$2
+BUILD_PIO=0
+if [ "$#" -lt 2 ] || [ "$CHUNKS_CNT" -le 0 ]; then
+	CHUNK_INDEX=0
+	CHUNKS_CNT=1
+elif [ "$CHUNK_INDEX" -gt "$CHUNKS_CNT" ]; then
+	CHUNK_INDEX=$CHUNKS_CNT
+elif [ "$CHUNK_INDEX" -eq "$CHUNKS_CNT" ]; then
+	BUILD_PIO=1
+fi
+
+if [ "$BUILD_PIO" -eq 0 ]; then
+	# ArduinoIDE Test
+	source ./.github/scripts/install-arduino-ide.sh
+	source ./.github/scripts/install-arduino-core-esp8266.sh
+
+	echo "Installing ESPAsyncTCP ..."
+	cp -rf "$GITHUB_WORKSPACE" "$ARDUINO_USR_PATH/libraries/ESPAsyncTCP"
+
+	FQBN="esp8266com:esp8266:generic:eesz=4M1M,ip=lm2f"
+	build_sketches "$FQBN" "$GITHUB_WORKSPACE/examples"
+	if [ ! "$OS_IS_WINDOWS" == "1" ]; then
+		echo "Installing ESPAsyncWebServer ..."
+		git clone https://github.com/me-no-dev/ESPAsyncWebServer "$ARDUINO_USR_PATH/libraries/ESPAsyncWebServer" > /dev/null 2>&1
+
+		echo "Installing ArduinoJson ..."
+		git clone https://github.com/bblanchon/ArduinoJson "$ARDUINO_USR_PATH/libraries/ArduinoJson" > /dev/null 2>&1
+
+		build_sketches "$FQBN" "$ARDUINO_USR_PATH/libraries/ESPAsyncWebServer/examples"
+	fi
+else
+	# PlatformIO Test
+	source ./.github/scripts/install-platformio.sh
+
+	echo "Installing ESPAsyncTCP ..."
+	python -m platformio lib --storage-dir "$GITHUB_WORKSPACE" install
+
+	BOARD="esp12e"
+	build_pio_sketches "$BOARD" "$GITHUB_WORKSPACE/examples"
+
+	if [[ "$OSTYPE" != "cygwin" ]] && [[ "$OSTYPE" != "msys" ]] && [[ "$OSTYPE" != "win32" ]]; then
+		echo "Installing ESPAsyncWebServer ..."
+		python -m platformio lib -g install https://github.com/me-no-dev/ESPAsyncWebServer.git > /dev/null 2>&1
+		git clone https://github.com/me-no-dev/ESPAsyncWebServer "$HOME/ESPAsyncWebServer" > /dev/null 2>&1
+
+		echo "Installing ArduinoJson ..."
+		python -m platformio lib -g install https://github.com/bblanchon/ArduinoJson.git > /dev/null 2>&1
+
+		build_pio_sketches "$BOARD" "$HOME/ESPAsyncWebServer/examples"
+	fi
+fi

lib/ESPAsyncTCP-esphome/.github/stale.yml

@@ -0,0 +1,31 @@
+# Configuration for probot-stale - https://github.com/probot/stale
+
+daysUntilStale: 60
+daysUntilClose: 14
+limitPerRun: 30
+staleLabel: stale
+exemptLabels:
+  - pinned
+  - security
+  - "to be implemented"
+  - "for reference"
+  - "move to PR"
+  - "enhancement"
+
+only: issues
+onlyLabels: []
+exemptProjects: false
+exemptMilestones: false
+exemptAssignees: false
+
+markComment: >
+  [STALE_SET] This issue has been automatically marked as stale because it has not had
+  recent activity. It will be closed in 14 days if no further activity occurs. Thank you
+  for your contributions.
+
+unmarkComment: >
+  [STALE_CLR] This issue has been removed from the stale queue. Please ensure activity to keep it openin the future.
+
+closeComment: >
+  [STALE_DEL] This stale issue has been automatically closed. Thank you for your contributions.
+

lib/ESPAsyncTCP-esphome/.github/workflows/push.yml

@@ -0,0 +1,32 @@
+name: ESP Async TCP CI
+
+on:
+  push:
+    branches:
+    - master
+    - release/*
+  pull_request:
+
+jobs:
+
+  build-pio:
+    name: PlatformIO on ${{ matrix.os }}
+    runs-on: ${{ matrix.os }}
+    strategy:
+      matrix:
+        os: [ubuntu-latest, windows-latest, macOS-latest]
+    steps:
+    - uses: actions/checkout@v3
+    - uses: actions/cache@v3
+      with:
+        path: |
+          ~/.cache/pip
+          ~/.platformio/.cache
+        key: ${{ runner.os }}-pio
+    - uses: actions/setup-python@v4
+      with:
+        python-version: '3.11'
+    - name: Install PlatformIO Core
+      run: pip install --upgrade platformio
+    - name: Build Tests
+      run: bash ./.github/scripts/on-push.sh 1 1

lib/ESPAsyncTCP-esphome/.gitignore

@@ -0,0 +1,2 @@
+
+.DS_Store

lib/ESPAsyncTCP-esphome/.piopm

@@ -0,0 +1 @@
+{"type": "library", "name": "ESPAsyncTCP-esphome", "version": "2.0.0", "spec": {"owner": "esphome", "id": 15476, "name": "ESPAsyncTCP-esphome", "requirements": null, "uri": null}}

lib/ESPAsyncTCP-esphome/LICENSE.txt

@@ -0,0 +1,165 @@
+                   GNU LESSER GENERAL PUBLIC LICENSE
+                       Version 3, 29 June 2007
+
+ Copyright (C) 2007 Free Software Foundation, Inc. <http://fsf.org/>
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+
+  This version of the GNU Lesser General Public License incorporates
+the terms and conditions of version 3 of the GNU General Public
+License, supplemented by the additional permissions listed below.
+
+  0. Additional Definitions.
+
+  As used herein, "this License" refers to version 3 of the GNU Lesser
+General Public License, and the "GNU GPL" refers to version 3 of the GNU
+General Public License.
+
+  "The Library" refers to a covered work governed by this License,
+other than an Application or a Combined Work as defined below.
+
+  An "Application" is any work that makes use of an interface provided
+by the Library, but which is not otherwise based on the Library.
+Defining a subclass of a class defined by the Library is deemed a mode
+of using an interface provided by the Library.
+
+  A "Combined Work" is a work produced by combining or linking an
+Application with the Library.  The particular version of the Library
+with which the Combined Work was made is also called the "Linked
+Version".
+
+  The "Minimal Corresponding Source" for a Combined Work means the
+Corresponding Source for the Combined Work, excluding any source code
+for portions of the Combined Work that, considered in isolation, are
+based on the Application, and not on the Linked Version.
+
+  The "Corresponding Application Code" for a Combined Work means the
+object code and/or source code for the Application, including any data
+and utility programs needed for reproducing the Combined Work from the
+Application, but excluding the System Libraries of the Combined Work.
+
+  1. Exception to Section 3 of the GNU GPL.
+
+  You may convey a covered work under sections 3 and 4 of this License
+without being bound by section 3 of the GNU GPL.
+
+  2. Conveying Modified Versions.
+
+  If you modify a copy of the Library, and, in your modifications, a
+facility refers to a function or data to be supplied by an Application
+that uses the facility (other than as an argument passed when the
+facility is invoked), then you may convey a copy of the modified
+version:
+
+   a) under this License, provided that you make a good faith effort to
+   ensure that, in the event an Application does not supply the
+   function or data, the facility still operates, and performs
+   whatever part of its purpose remains meaningful, or
+
+   b) under the GNU GPL, with none of the additional permissions of
+   this License applicable to that copy.
+
+  3. Object Code Incorporating Material from Library Header Files.
+
+  The object code form of an Application may incorporate material from
+a header file that is part of the Library.  You may convey such object
+code under terms of your choice, provided that, if the incorporated
+material is not limited to numerical parameters, data structure
+layouts and accessors, or small macros, inline functions and templates
+(ten or fewer lines in length), you do both of the following:
+
+   a) Give prominent notice with each copy of the object code that the
+   Library is used in it and that the Library and its use are
+   covered by this License.
+
+   b) Accompany the object code with a copy of the GNU GPL and this license
+   document.
+
+  4. Combined Works.
+
+  You may convey a Combined Work under terms of your choice that,
+taken together, effectively do not restrict modification of the
+portions of the Library contained in the Combined Work and reverse
+engineering for debugging such modifications, if you also do each of
+the following:
+
+   a) Give prominent notice with each copy of the Combined Work that
+   the Library is used in it and that the Library and its use are
+   covered by this License.
+
+   b) Accompany the Combined Work with a copy of the GNU GPL and this license
+   document.
+
+   c) For a Combined Work that displays copyright notices during
+   execution, include the copyright notice for the Library among
+   these notices, as well as a reference directing the user to the
+   copies of the GNU GPL and this license document.
+
+   d) Do one of the following:
+
+       0) Convey the Minimal Corresponding Source under the terms of this
+       License, and the Corresponding Application Code in a form
+       suitable for, and under terms that permit, the user to
+       recombine or relink the Application with a modified version of
+       the Linked Version to produce a modified Combined Work, in the
+       manner specified by section 6 of the GNU GPL for conveying
+       Corresponding Source.
+
+       1) Use a suitable shared library mechanism for linking with the
+       Library.  A suitable mechanism is one that (a) uses at run time
+       a copy of the Library already present on the user's computer
+       system, and (b) will operate properly with a modified version
+       of the Library that is interface-compatible with the Linked
+       Version.
+
+   e) Provide Installation Information, but only if you would otherwise
+   be required to provide such information under section 6 of the
+   GNU GPL, and only to the extent that such information is
+   necessary to install and execute a modified version of the
+   Combined Work produced by recombining or relinking the
+   Application with a modified version of the Linked Version. (If
+   you use option 4d0, the Installation Information must accompany
+   the Minimal Corresponding Source and Corresponding Application
+   Code. If you use option 4d1, you must provide the Installation
+   Information in the manner specified by section 6 of the GNU GPL
+   for conveying Corresponding Source.)
+
+  5. Combined Libraries.
+
+  You may place library facilities that are a work based on the
+Library side by side in a single library together with other library
+facilities that are not Applications and are not covered by this
+License, and convey such a combined library under terms of your
+choice, if you do both of the following:
+
+   a) Accompany the combined library with a copy of the same work based
+   on the Library, uncombined with any other library facilities,
+   conveyed under the terms of this License.
+
+   b) Give prominent notice with the combined library that part of it
+   is a work based on the Library, and explaining where to find the
+   accompanying uncombined form of the same work.
+
+  6. Revised Versions of the GNU Lesser General Public License.
+
+  The Free Software Foundation may publish revised and/or new versions
+of the GNU Lesser General Public License from time to time. Such new
+versions will be similar in spirit to the present version, but may
+differ in detail to address new problems or concerns.
+
+  Each version is given a distinguishing version number. If the
+Library as you received it specifies that a certain numbered version
+of the GNU Lesser General Public License "or any later version"
+applies to it, you have the option of following the terms and
+conditions either of that published version or of any later version
+published by the Free Software Foundation. If the Library as you
+received it does not specify a version number of the GNU Lesser
+General Public License, you may choose any version of the GNU Lesser
+General Public License ever published by the Free Software Foundation.
+
+  If the Library as you received it specifies that a proxy can decide
+whether future versions of the GNU Lesser General Public License shall
+apply, that proxy's public statement of acceptance of any version is
+permanent authorization for you to choose that version for the
+Library.

lib/ESPAsyncTCP-esphome/README.md

@@ -0,0 +1,33 @@
+# ESPAsyncTCP 
+
+A fork of the [AsyncTCP](https://github.com/me-no-dev/AsyncTCP) library by [@me-no-dev](https://github.com/me-no-dev) for [ESPHome](https://esphome.io).
+
+### Async TCP Library for ESP8266 Arduino
+
+For ESP32 look [HERE](https://github.com/me-no-dev/AsyncTCP)
+
+[![Join the chat at https://gitter.im/me-no-dev/ESPAsyncWebServer](https://badges.gitter.im/me-no-dev/ESPAsyncWebServer.svg)](https://gitter.im/me-no-dev/ESPAsyncWebServer?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)
+
+This is a fully asynchronous TCP library, aimed at enabling trouble-free, multi-connection network environment for Espressif's ESP8266 MCUs.
+
+This library is the base for [ESPAsyncWebServer](https://github.com/me-no-dev/ESPAsyncWebServer)
+
+## AsyncClient and AsyncServer
+The base classes on which everything else is built. They expose all possible scenarios, but are really raw and require more skills to use.
+
+## AsyncPrinter
+This class can be used to send data like any other ```Print``` interface (```Serial``` for example).
+The object then can be used outside of the Async callbacks (the loop) and receive asynchronously data using ```onData```. The object can be checked if the underlying ```AsyncClient```is connected, or hook to the ```onDisconnect``` callback.
+
+## AsyncTCPbuffer
+This class is really similar to the ```AsyncPrinter```, but it differs in the fact that it can buffer some of the incoming data.
+
+## SyncClient
+It is exactly what it sounds like. This is a standard, blocking TCP Client, similar to the one included in ```ESP8266WiFi```
+
+## Libraries and projects that use AsyncTCP
+- [ESP Async Web Server](https://github.com/me-no-dev/ESPAsyncWebServer)
+- [Async MQTT client](https://github.com/marvinroger/async-mqtt-client)
+- [arduinoWebSockets](https://github.com/Links2004/arduinoWebSockets)
+- [ESP8266 Smart Home](https://github.com/baruch/esp8266_smart_home)
+- [KBox Firmware](https://github.com/sarfata/kbox-firmware)

lib/ESPAsyncTCP-esphome/examples/ClientServer/Client/Client.ino

@@ -0,0 +1,62 @@
+#include <ESP8266WiFi.h>
+#include <ESPAsyncTCP.h>
+
+extern "C" {
+#include <osapi.h>
+#include <os_type.h>
+}
+
+#include "config.h"
+
+static os_timer_t intervalTimer;
+
+static void replyToServer(void* arg) {
+	AsyncClient* client = reinterpret_cast<AsyncClient*>(arg);
+
+	// send reply
+	if (client->space() > 32 && client->canSend()) {
+		char message[32];
+		sprintf(message, "this is from %s", WiFi.localIP().toString().c_str());
+		client->add(message, strlen(message));
+		client->send();
+	}
+}
+
+/* event callbacks */
+static void handleData(void* arg, AsyncClient* client, void *data, size_t len) {
+	Serial.printf("\n data received from %s \n", client->remoteIP().toString().c_str());
+	Serial.write((uint8_t*)data, len);
+
+	os_timer_arm(&intervalTimer, 2000, true); // schedule for reply to server at next 2s
+}
+
+void onConnect(void* arg, AsyncClient* client) {
+	Serial.printf("\n client has been connected to %s on port %d \n", SERVER_HOST_NAME, TCP_PORT);
+	replyToServer(client);
+}
+
+
+void setup() {
+	Serial.begin(115200);
+	delay(20);
+
+	// connects to access point
+	WiFi.mode(WIFI_STA);
+	WiFi.begin(SSID, PASSWORD);
+	while (WiFi.status() != WL_CONNECTED) {
+		Serial.print('.');
+		delay(500);
+	}
+
+	AsyncClient* client = new AsyncClient;
+	client->onData(&handleData, client);
+	client->onConnect(&onConnect, client);
+	client->connect(SERVER_HOST_NAME, TCP_PORT);
+
+	os_timer_disarm(&intervalTimer);
+	os_timer_setfn(&intervalTimer, &replyToServer, client);
+}
+
+void loop() {
+
+}

lib/ESPAsyncTCP-esphome/examples/ClientServer/Client/config.h

@@ -0,0 +1,23 @@
+#ifndef CONFIG_H
+#define CONFIG_H
+
+/*
+ * This example demonstrate how to use asynchronous client & server APIs
+ * in order to establish tcp socket connections in client server manner.
+ * server is running (on port 7050) on one ESP, acts as AP, and other clients running on
+ * remaining ESPs acts as STAs. after connection establishment between server and clients
+ * there is a simple message transfer in every 2s. clients connect to server via it's host name
+ * (in this case 'esp_server') with help of DNS service running on server side.
+ *
+ * Note: default MSS for ESPAsyncTCP is 536 byte and defualt ACK timeout is 5s.
+*/
+
+#define SSID "ESP-TEST"
+#define PASSWORD "123456789"
+
+#define SERVER_HOST_NAME "esp_server"
+
+#define TCP_PORT 7050
+#define DNS_PORT 53
+
+#endif // CONFIG_H

lib/ESPAsyncTCP-esphome/examples/ClientServer/Server/Server.ino

@@ -0,0 +1,73 @@
+#include <ESP8266WiFi.h>
+#include <ESPAsyncTCP.h>
+#include <DNSServer.h>
+#include <vector>
+
+#include "config.h"
+
+static DNSServer DNS;
+
+static std::vector<AsyncClient*> clients; // a list to hold all clients
+
+ /* clients events */
+static void handleError(void* arg, AsyncClient* client, int8_t error) {
+	Serial.printf("\n connection error %s from client %s \n", client->errorToString(error), client->remoteIP().toString().c_str());
+}
+
+static void handleData(void* arg, AsyncClient* client, void *data, size_t len) {
+	Serial.printf("\n data received from client %s \n", client->remoteIP().toString().c_str());
+	Serial.write((uint8_t*)data, len);
+
+	// reply to client
+	if (client->space() > 32 && client->canSend()) {
+		char reply[32];
+		sprintf(reply, "this is from %s", SERVER_HOST_NAME);
+		client->add(reply, strlen(reply));
+		client->send();
+	}
+}
+
+static void handleDisconnect(void* arg, AsyncClient* client) {
+	Serial.printf("\n client %s disconnected \n", client->remoteIP().toString().c_str());
+}
+
+static void handleTimeOut(void* arg, AsyncClient* client, uint32_t time) {
+	Serial.printf("\n client ACK timeout ip: %s \n", client->remoteIP().toString().c_str());
+}
+
+
+/* server events */
+static void handleNewClient(void* arg, AsyncClient* client) {
+	Serial.printf("\n new client has been connected to server, ip: %s", client->remoteIP().toString().c_str());
+
+	// add to list
+	clients.push_back(client);
+	
+	// register events
+	client->onData(&handleData, NULL);
+	client->onError(&handleError, NULL);
+	client->onDisconnect(&handleDisconnect, NULL);
+	client->onTimeout(&handleTimeOut, NULL);
+}
+
+void setup() {
+	Serial.begin(115200);
+	delay(20);
+	
+	// create access point
+	while (!WiFi.softAP(SSID, PASSWORD, 6, false, 15)) {
+		delay(500);
+	}
+
+	// start dns server
+	if (!DNS.start(DNS_PORT, SERVER_HOST_NAME, WiFi.softAPIP()))
+		Serial.printf("\n failed to start dns service \n");
+
+	AsyncServer* server = new AsyncServer(TCP_PORT); // start listening on tcp port 7050
+	server->onClient(&handleNewClient, server);
+	server->begin();
+}
+
+void loop() {
+	DNS.processNextRequest();
+}

lib/ESPAsyncTCP-esphome/examples/ClientServer/Server/config.h

@@ -0,0 +1,23 @@
+#ifndef CONFIG_H
+#define CONFIG_H
+
+/*
+ * This example demonstrate how to use asynchronous client & server APIs
+ * in order to establish tcp socket connections in client server manner.
+ * server is running (on port 7050) on one ESP, acts as AP, and other clients running on
+ * remaining ESPs acts as STAs. after connection establishment between server and clients
+ * there is a simple message transfer in every 2s. clients connect to server via it's host name
+ * (in this case 'esp_server') with help of DNS service running on server side.
+ *
+ * Note: default MSS for ESPAsyncTCP is 536 byte and defualt ACK timeout is 5s.
+*/
+
+#define SSID "ESP-TEST"
+#define PASSWORD "123456789"
+
+#define SERVER_HOST_NAME "esp_server"
+
+#define TCP_PORT 7050
+#define DNS_PORT 53
+
+#endif // CONFIG_H

lib/ESPAsyncTCP-esphome/examples/SyncClient/SyncClient.ino

@@ -0,0 +1,54 @@
+#ifdef ESP8266
+#include <ESP8266WiFi.h>
+#include <ESP8266mDNS.h>
+#include <ArduinoOTA.h>
+#else
+#include <ESP31BWiFi.h>
+#endif
+#include "ESPAsyncTCP.h"
+#include "SyncClient.h"
+
+const char* ssid = "**********";
+const char* password = "************";
+
+void setup(){
+  Serial.begin(115200);
+  WiFi.begin(ssid, password);
+  if (WiFi.waitForConnectResult() != WL_CONNECTED) {
+    Serial.printf("WiFi Failed!\n");
+    return;
+  }
+  Serial.printf("WiFi Connected!\n");
+  Serial.println(WiFi.localIP());
+#ifdef ESP8266
+  ArduinoOTA.begin();
+#endif
+  
+  SyncClient client;
+  if(!client.connect("www.google.com", 80)){
+    Serial.println("Connect Failed");
+    return;
+  }
+  client.setTimeout(2);
+  if(client.printf("GET / HTTP/1.1\r\nHost: www.google.com\r\nConnection: close\r\n\r\n") > 0){
+    while(client.connected() && client.available() == 0){
+      delay(1);
+    }
+    while(client.available()){
+      Serial.write(client.read());
+    }
+    if(client.connected()){
+      client.stop();
+    }
+  } else {
+    client.stop();
+    Serial.println("Send Failed");
+    while(client.connected()) delay(0);
+  }
+}
+
+void loop(){
+#ifdef ESP8266
+  ArduinoOTA.handle();
+#endif
+}

lib/ESPAsyncTCP-esphome/library.json

@@ -0,0 +1,22 @@
+{
+  "name":"ESPAsyncTCP-esphome",
+  "description":"Asynchronous TCP Library for ESP8266",
+  "keywords":"async,tcp",
+  "authors":
+  {
+    "name": "Hristo Gochkov",
+    "maintainer": true
+  },
+  "repository":
+  {
+    "type": "git",
+    "url": "https://github.com/esphome/ESPAsyncTCP.git"
+  },
+  "version": "2.0.0",
+  "license": "LGPL-3.0",
+  "frameworks": "arduino",
+  "platforms": "espressif8266",
+  "build": {
+    "libCompatMode": 2
+  }
+}

lib/ESPAsyncTCP-esphome/src/AsyncPrinter.cpp

@@ -0,0 +1,214 @@
+/*
+  Asynchronous TCP library for Espressif MCUs
+
+  Copyright (c) 2016 Hristo Gochkov. All rights reserved.
+  This file is part of the esp8266 core for Arduino environment.
+
+  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
+*/
+
+#include "AsyncPrinter.h"
+
+AsyncPrinter::AsyncPrinter()
+  : _client(NULL)
+  , _data_cb(NULL)
+  , _data_arg(NULL)
+  , _close_cb(NULL)
+  , _close_arg(NULL)
+  , _tx_buffer(NULL)
+  , _tx_buffer_size(TCP_MSS)
+  , next(NULL)
+{}
+
+AsyncPrinter::AsyncPrinter(AsyncClient *client, size_t txBufLen)
+  : _client(client)
+  , _data_cb(NULL)
+  , _data_arg(NULL)
+  , _close_cb(NULL)
+  , _close_arg(NULL)
+  , _tx_buffer(NULL)
+  , _tx_buffer_size(txBufLen)
+  , next(NULL)
+{
+  _attachCallbacks();
+  _tx_buffer = new (std::nothrow) cbuf(_tx_buffer_size);
+  if(_tx_buffer == NULL) {
+    panic(); //What should we do?
+  }
+}
+
+AsyncPrinter::~AsyncPrinter(){
+  _on_close();
+}
+
+void AsyncPrinter::onData(ApDataHandler cb, void *arg){
+  _data_cb = cb;
+  _data_arg = arg;
+}
+
+void AsyncPrinter::onClose(ApCloseHandler cb, void *arg){
+  _close_cb = cb;
+  _close_arg = arg;
+}
+
+int AsyncPrinter::connect(IPAddress ip, uint16_t port){
+  if(_client != NULL && connected())
+    return 0;
+  _client = new (std::nothrow) AsyncClient();
+  if (_client == NULL) {
+    panic();
+  }
+
+  _client->onConnect([](void *obj, AsyncClient *c){ ((AsyncPrinter*)(obj))->_onConnect(c); }, this);
+  if(_client->connect(ip, port)){
+    while(_client && _client->state() < 4)
+      delay(1);
+    return connected();
+  }
+  return 0;
+}
+
+int AsyncPrinter::connect(const char *host, uint16_t port){
+  if(_client != NULL && connected())
+    return 0;
+  _client = new (std::nothrow) AsyncClient();
+  if (_client == NULL) {
+    panic();
+  }
+
+  _client->onConnect([](void *obj, AsyncClient *c){ ((AsyncPrinter*)(obj))->_onConnect(c); }, this);
+  if(_client->connect(host, port)){
+    while(_client && _client->state() < 4)
+      delay(1);
+    return connected();
+  }
+  return 0;
+}
+
+void AsyncPrinter::_onConnect(AsyncClient *c){
+  (void)c;
+  if(_tx_buffer != NULL){
+    cbuf *b = _tx_buffer;
+    _tx_buffer = NULL;
+    delete b;
+  }
+  _tx_buffer = new (std::nothrow) cbuf(_tx_buffer_size);
+  if(_tx_buffer) {
+    panic();
+  }
+
+  _attachCallbacks();
+}
+
+AsyncPrinter::operator bool(){ return connected(); }
+
+AsyncPrinter & AsyncPrinter::operator=(const AsyncPrinter &other){
+  if(_client != NULL){
+    _client->close(true);
+    _client = NULL;
+  }
+  _tx_buffer_size = other._tx_buffer_size;
+  if(_tx_buffer != NULL){
+    cbuf *b = _tx_buffer;
+    _tx_buffer = NULL;
+    delete b;
+  }
+  _tx_buffer = new (std::nothrow) cbuf(other._tx_buffer_size);
+  if(_tx_buffer == NULL) {
+    panic();
+  }
+
+  _client = other._client;
+  _attachCallbacks();
+  return *this;
+}
+
+size_t AsyncPrinter::write(uint8_t data){
+  return write(&data, 1);
+}
+
+size_t AsyncPrinter::write(const uint8_t *data, size_t len){
+  if(_tx_buffer == NULL || !connected())
+    return 0;
+  size_t toWrite = 0;
+  size_t toSend = len;
+  while(_tx_buffer->room() < toSend){
+    toWrite = _tx_buffer->room();
+    _tx_buffer->write((const char*)data, toWrite);
+    while(connected() && !_client->canSend())
+      delay(0);
+    if(!connected())
+      return 0; // or len - toSend;
+    _sendBuffer();
+    toSend -= toWrite;
+  }
+  _tx_buffer->write((const char*)(data+(len - toSend)), toSend);
+  while(connected() && !_client->canSend()) delay(0);
+  if(!connected()) return 0; // or len - toSend;
+  _sendBuffer();
+  return len;
+}
+
+bool AsyncPrinter::connected(){
+  return (_client != NULL && _client->connected());
+}
+
+void AsyncPrinter::close(){
+  if(_client != NULL)
+    _client->close(true);
+}
+
+size_t AsyncPrinter::_sendBuffer(){
+  size_t available = _tx_buffer->available();
+  if(!connected() || !_client->canSend() || available == 0)
+    return 0;
+  size_t sendable = _client->space();
+  if(sendable < available)
+    available= sendable;
+  char *out = new (std::nothrow) char[available];
+  if (out == NULL) {
+    panic(); // Connection should be aborted instead
+  }
+
+  _tx_buffer->read(out, available);
+  size_t sent = _client->write(out, available);
+  delete out;
+  return sent;
+}
+
+void AsyncPrinter::_onData(void *data, size_t len){
+  if(_data_cb)
+    _data_cb(_data_arg, this, (uint8_t*)data, len);
+}
+
+void AsyncPrinter::_on_close(){
+  if(_client != NULL){
+    _client = NULL;
+  }
+  if(_tx_buffer != NULL){
+    cbuf *b = _tx_buffer;
+    _tx_buffer = NULL;
+    delete b;
+  }
+  if(_close_cb)
+    _close_cb(_close_arg, this);
+}
+
+void AsyncPrinter::_attachCallbacks(){
+  _client->onPoll([](void *obj, AsyncClient* c){ (void)c; ((AsyncPrinter*)(obj))->_sendBuffer(); }, this);
+  _client->onAck([](void *obj, AsyncClient* c, size_t len, uint32_t time){  (void)c; (void)len; (void)time; ((AsyncPrinter*)(obj))->_sendBuffer(); }, this);
+  _client->onDisconnect([](void *obj, AsyncClient* c){ ((AsyncPrinter*)(obj))->_on_close(); delete c; }, this);
+  _client->onData([](void *obj, AsyncClient* c, void *data, size_t len){ (void)c; ((AsyncPrinter*)(obj))->_onData(data, len); }, this);
+}

lib/ESPAsyncTCP-esphome/src/AsyncPrinter.h

@@ -0,0 +1,73 @@
+/*
+  Asynchronous TCP library for Espressif MCUs
+
+  Copyright (c) 2016 Hristo Gochkov. All rights reserved.
+  This file is part of the esp8266 core for Arduino environment.
+
+  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 ASYNCPRINTER_H_
+#define ASYNCPRINTER_H_
+
+#include "Arduino.h"
+#include "ESPAsyncTCP.h"
+#include "cbuf.h"
+
+class AsyncPrinter;
+
+typedef std::function<void(void*, AsyncPrinter*, uint8_t*, size_t)> ApDataHandler;
+typedef std::function<void(void*, AsyncPrinter*)> ApCloseHandler;
+
+class AsyncPrinter: public Print {
+  private:
+    AsyncClient *_client;
+    ApDataHandler _data_cb;
+    void *_data_arg;
+    ApCloseHandler _close_cb;
+    void *_close_arg;
+    cbuf *_tx_buffer;
+    size_t _tx_buffer_size;
+
+    void _onConnect(AsyncClient *c);
+  public:
+    AsyncPrinter *next;
+
+    AsyncPrinter();
+    AsyncPrinter(AsyncClient *client, size_t txBufLen = TCP_MSS);
+    virtual ~AsyncPrinter();
+
+    int connect(IPAddress ip, uint16_t port);
+    int connect(const char *host, uint16_t port);
+
+    void onData(ApDataHandler cb, void *arg);
+    void onClose(ApCloseHandler cb, void *arg);
+
+    operator bool();
+    AsyncPrinter & operator=(const AsyncPrinter &other);
+
+    size_t write(uint8_t data);
+    size_t write(const uint8_t *data, size_t len);
+
+    bool connected();
+    void close();
+
+    size_t _sendBuffer();
+    void _onData(void *data, size_t len);
+    void _on_close();
+    void _attachCallbacks();
+};
+
+#endif /* ASYNCPRINTER_H_ */

lib/ESPAsyncTCP-esphome/src/DebugPrintMacros.h

@@ -0,0 +1,112 @@
+#ifndef _DEBUG_PRINT_MACROS_H
+#define _DEBUG_PRINT_MACROS_H
+// Some customizable print macros to suite the debug needs de jour.
+
+// Debug macros
+// #include <pgmspace.h>
+// https://stackoverflow.com/questions/8487986/file-macro-shows-full-path
+// This value is resolved at compile time.
+#define _FILENAME_ strrchr("/" __FILE__, '/')
+
+// #define DEBUG_ESP_ASYNC_TCP 1
+// #define DEBUG_ESP_TCP_SSL 1
+// #define DEBUG_ESP_PORT Serial
+
+#if defined(DEBUG_ESP_PORT) && !defined(DEBUG_TIME_STAMP_FMT)
+#define DEBUG_TIME_STAMP_FMT "%06u.%03u "
+struct _DEBUG_TIME_STAMP {
+  unsigned dec;
+  unsigned whole;
+};
+inline struct _DEBUG_TIME_STAMP debugTimeStamp(void) {
+  struct _DEBUG_TIME_STAMP st;
+  unsigned now = millis() % 1000000000;
+  st.dec = now % 1000;
+  st.whole = now / 1000;
+  return st;
+}
+#endif
+
+#if defined(DEBUG_ESP_PORT) && !defined(DEBUG_ESP_PORT_PRINTF)
+
+#ifdef __cplusplus
+#define DEBUG_ESP_PORT_PRINTF(format, ...)   DEBUG_ESP_PORT.printf((format), ##__VA_ARGS__)
+#define DEBUG_ESP_PORT_PRINTF_F(format, ...) DEBUG_ESP_PORT.printf_P(PSTR(format), ##__VA_ARGS__)
+#define DEBUG_ESP_PORT_FLUSH DEBUG_ESP_PORT.flush
+#else
+// Handle debug printing from .c without CPP Stream, Print, ... classes
+// Cannot handle flash strings in this setting
+#define DEBUG_ESP_PORT_PRINTF ets_uart_printf
+#define DEBUG_ESP_PORT_PRINTF_F ets_uart_printf
+#define DEBUG_ESP_PORT_FLUSH (void)0
+#endif
+
+#endif
+
+#if defined(DEBUG_ESP_PORT) && !defined(DEBUG_GENERIC)
+  #define DEBUG_GENERIC( module, format, ... ) \
+    do { \
+      struct _DEBUG_TIME_STAMP st = debugTimeStamp(); \
+      DEBUG_ESP_PORT_PRINTF( (DEBUG_TIME_STAMP_FMT module " " format), st.whole, st.dec, ##__VA_ARGS__ ); \
+    } while(false)
+#endif
+#if defined(DEBUG_ESP_PORT) && !defined(DEBUG_GENERIC_F)
+  #define DEBUG_GENERIC_F( module, format, ... ) \
+    do { \
+      struct _DEBUG_TIME_STAMP st = debugTimeStamp(); \
+      DEBUG_ESP_PORT_PRINTF_F( (DEBUG_TIME_STAMP_FMT module " " format), st.whole, st.dec, ##__VA_ARGS__ ); \
+    } while(false)
+#endif
+
+#if defined(DEBUG_GENERIC) && !defined(ASSERT_GENERIC)
+#define ASSERT_GENERIC( a, module ) \
+  do { \
+    if ( !(a) ) { \
+      DEBUG_GENERIC( module, "%s:%s:%u: ASSERT("#a") failed!\n", __FILE__, __func__, __LINE__); \
+      DEBUG_ESP_PORT_FLUSH(); \
+    } \
+  } while(false)
+#endif
+#if defined(DEBUG_GENERIC_F) && !defined(ASSERT_GENERIC_F)
+#define ASSERT_GENERIC_F( a, module ) \
+  do { \
+    if ( !(a) ) { \
+      DEBUG_GENERIC_F( module, "%s:%s:%u: ASSERT("#a") failed!\n", __FILE__, __func__, __LINE__); \
+      DEBUG_ESP_PORT_FLUSH(); \
+    } \
+  } while(false)
+#endif
+
+#ifndef DEBUG_GENERIC
+#define DEBUG_GENERIC(...) do { (void)0;} while(false)
+#endif
+
+#ifndef DEBUG_GENERIC_F
+#define DEBUG_GENERIC_F(...) do { (void)0;} while(false)
+#endif
+
+#ifndef ASSERT_GENERIC
+#define ASSERT_GENERIC(...) do { (void)0;} while(false)
+#endif
+
+#ifndef ASSERT_GENERIC_F
+#define ASSERT_GENERIC_F(...) do { (void)0;} while(false)
+#endif
+
+#ifndef DEBUG_ESP_PRINTF
+#define DEBUG_ESP_PRINTF( format, ...) DEBUG_GENERIC_F("[%s]", format, &_FILENAME_[1], ##__VA_ARGS__)
+#endif
+
+#if defined(DEBUG_ESP_ASYNC_TCP) && !defined(ASYNC_TCP_DEBUG)
+#define ASYNC_TCP_DEBUG( format, ...) DEBUG_GENERIC_F("[ASYNC_TCP]", format, ##__VA_ARGS__)
+#endif
+
+#ifndef ASYNC_TCP_ASSERT
+#define ASYNC_TCP_ASSERT( a ) ASSERT_GENERIC_F( (a), "[ASYNC_TCP]")
+#endif
+
+#if defined(DEBUG_ESP_TCP_SSL) && !defined(TCP_SSL_DEBUG)
+#define TCP_SSL_DEBUG( format, ...) DEBUG_GENERIC_F("[TCP_SSL]", format, ##__VA_ARGS__)
+#endif
+
+#endif //_DEBUG_PRINT_MACROS_H

lib/ESPAsyncTCP-esphome/src/ESPAsyncTCP.h

@@ -0,0 +1,324 @@
+/*
+  Asynchronous TCP library for Espressif MCUs
+
+  Copyright (c) 2016 Hristo Gochkov. All rights reserved.
+  This file is part of the esp8266 core for Arduino environment.
+
+  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 ASYNCTCP_H_
+#define ASYNCTCP_H_
+
+#include <async_config.h>
+#include "IPAddress.h"
+#include <functional>
+#include <memory>
+
+extern "C" {
+    #include "lwip/init.h"
+    #include "lwip/err.h"
+    #include "lwip/pbuf.h"
+};
+
+class AsyncClient;
+class AsyncServer;
+class ACErrorTracker;
+
+#define ASYNC_MAX_ACK_TIME 5000
+#define ASYNC_WRITE_FLAG_COPY 0x01 //will allocate new buffer to hold the data while sending (else will hold reference to the data given)
+#define ASYNC_WRITE_FLAG_MORE 0x02 //will not send PSH flag, meaning that there should be more data to be sent before the application should react.
+
+struct tcp_pcb;
+struct ip_addr;
+#if ASYNC_TCP_SSL_ENABLED
+struct SSL_;
+typedef struct SSL_ SSL;
+struct SSL_CTX_;
+typedef struct SSL_CTX_ SSL_CTX;
+#endif
+
+typedef std::function<void(void*, AsyncClient*)> AcConnectHandler;
+typedef std::function<void(void*, AsyncClient*, size_t len, uint32_t time)> AcAckHandler;
+typedef std::function<void(void*, AsyncClient*, err_t error)> AcErrorHandler;
+typedef std::function<void(void*, AsyncClient*, void *data, size_t len)> AcDataHandler;
+typedef std::function<void(void*, AsyncClient*, struct pbuf *pb)> AcPacketHandler;
+typedef std::function<void(void*, AsyncClient*, uint32_t time)> AcTimeoutHandler;
+typedef std::function<void(void*, size_t event)> AsNotifyHandler;
+
+enum error_events {
+  EE_OK = 0,
+  EE_ABORTED,       // Callback or foreground aborted connections
+  EE_ERROR_CB,      // Stack initiated aborts via error Callbacks.
+  EE_CONNECTED_CB,
+  EE_RECV_CB,
+  EE_ACCEPT_CB,
+  EE_MAX
+};
+// DEBUG_MORE is for gathering more information on which CBs close events are
+// occuring and count.
+// #define DEBUG_MORE 1
+class ACErrorTracker {
+  private:
+    AsyncClient *_client;
+    err_t _close_error;
+    int _errored;
+#if DEBUG_ESP_ASYNC_TCP
+    size_t _connectionId;
+#endif
+#ifdef DEBUG_MORE
+    AsNotifyHandler _error_event_cb;
+    void* _error_event_cb_arg;
+#endif
+
+  protected:
+    friend class AsyncClient;
+    friend class AsyncServer;
+#ifdef DEBUG_MORE
+    void onErrorEvent(AsNotifyHandler cb, void *arg);
+#endif
+#if DEBUG_ESP_ASYNC_TCP
+    void setConnectionId(size_t id) { _connectionId=id;}
+    size_t getConnectionId(void) { return _connectionId;}
+#endif
+    void setCloseError(err_t e);
+    void setErrored(size_t errorEvent);
+    err_t getCallbackCloseError(void);
+    void clearClient(void){ if (_client) _client = NULL;}
+
+  public:
+    err_t getCloseError(void) const { return _close_error;}
+    bool hasClient(void) const { return (_client != NULL);}
+    ACErrorTracker(AsyncClient *c);
+    ~ACErrorTracker() {}
+};
+
+class AsyncClient {
+  protected:
+    friend class AsyncTCPbuffer;
+    friend class AsyncServer;
+    tcp_pcb* _pcb;
+    AcConnectHandler _connect_cb;
+    void* _connect_cb_arg;
+    AcConnectHandler _discard_cb;
+    void* _discard_cb_arg;
+    AcAckHandler _sent_cb;
+    void* _sent_cb_arg;
+    AcErrorHandler _error_cb;
+    void* _error_cb_arg;
+    AcDataHandler _recv_cb;
+    void* _recv_cb_arg;
+    AcPacketHandler _pb_cb;
+    void* _pb_cb_arg;
+    AcTimeoutHandler _timeout_cb;
+    void* _timeout_cb_arg;
+    AcConnectHandler _poll_cb;
+    void* _poll_cb_arg;
+    bool _pcb_busy;
+#if ASYNC_TCP_SSL_ENABLED
+    bool _pcb_secure;
+    bool _handshake_done;
+#endif
+    uint32_t _pcb_sent_at;
+    bool _close_pcb;
+    bool _ack_pcb;
+    uint32_t _tx_unacked_len;
+    uint32_t _tx_acked_len;
+    uint32_t _rx_ack_len;
+    uint32_t _rx_last_packet;
+    uint32_t _rx_since_timeout;
+    uint32_t _ack_timeout;
+    uint16_t _connect_port;
+    u8_t _recv_pbuf_flags;
+    std::shared_ptr<ACErrorTracker> _errorTracker;
+
+    void _close();
+    void _connected(std::shared_ptr<ACErrorTracker>& closeAbort, void* pcb, err_t err);
+    void _error(err_t err);
+#if ASYNC_TCP_SSL_ENABLED
+    void _ssl_error(int8_t err);
+#endif
+    void _poll(std::shared_ptr<ACErrorTracker>& closeAbort, tcp_pcb* pcb);
+    void _sent(std::shared_ptr<ACErrorTracker>& closeAbort, tcp_pcb* pcb, uint16_t len);
+#if LWIP_VERSION_MAJOR == 1
+    void _dns_found(struct ip_addr *ipaddr);
+#else
+    void _dns_found(const ip_addr *ipaddr);
+#endif
+    static err_t _s_poll(void *arg, struct tcp_pcb *tpcb);
+    static err_t _s_recv(void *arg, struct tcp_pcb *tpcb, struct pbuf *pb, err_t err);
+    static void _s_error(void *arg, err_t err);
+    static err_t _s_sent(void *arg, struct tcp_pcb *tpcb, uint16_t len);
+    static err_t _s_connected(void* arg, void* tpcb, err_t err);
+#if LWIP_VERSION_MAJOR == 1
+    static void _s_dns_found(const char *name, struct ip_addr *ipaddr, void *arg);
+#else
+    static void _s_dns_found(const char *name, const ip_addr *ipaddr, void *arg);
+#endif
+#if ASYNC_TCP_SSL_ENABLED
+    static void _s_data(void *arg, struct tcp_pcb *tcp, uint8_t * data, size_t len);
+    static void _s_handshake(void *arg, struct tcp_pcb *tcp, SSL *ssl);
+    static void _s_ssl_error(void *arg, struct tcp_pcb *tcp, int8_t err);
+#endif
+    std::shared_ptr<ACErrorTracker> getACErrorTracker(void) const { return _errorTracker; };
+    void setCloseError(err_t e) const { _errorTracker->setCloseError(e);}
+
+  public:
+    AsyncClient* prev;
+    AsyncClient* next;
+
+#if ASYNC_TCP_SSL_ENABLED
+    AsyncClient(tcp_pcb* pcb = 0, SSL_CTX * ssl_ctx = NULL);
+#else
+    AsyncClient(tcp_pcb* pcb = 0);
+#endif
+    ~AsyncClient();
+
+    AsyncClient & operator=(const AsyncClient &other);
+    AsyncClient & operator+=(const AsyncClient &other);
+
+    bool operator==(const AsyncClient &other);
+
+    bool operator!=(const AsyncClient &other) {
+      return !(*this == other);
+    }
+#if ASYNC_TCP_SSL_ENABLED
+    bool connect(IPAddress ip, uint16_t port, bool secure=false);
+    bool connect(const char* host, uint16_t port, bool secure=false);
+#else
+    bool connect(IPAddress ip, uint16_t port);
+    bool connect(const char* host, uint16_t port);
+#endif
+    void close(bool now = false);
+    void stop();
+    void abort();
+    bool free();
+
+    bool canSend();//ack is not pending
+    size_t space();
+    size_t add(const char* data, size_t size, uint8_t apiflags=0);//add for sending
+    bool send();//send all data added with the method above
+    size_t ack(size_t len); //ack data that you have not acked using the method below
+    void ackLater(){ _ack_pcb = false; } //will not ack the current packet. Call from onData
+    bool isRecvPush(){ return !!(_recv_pbuf_flags & PBUF_FLAG_PUSH); }
+#if DEBUG_ESP_ASYNC_TCP
+    size_t getConnectionId(void) const { return _errorTracker->getConnectionId();}
+#endif
+#if ASYNC_TCP_SSL_ENABLED
+    SSL *getSSL();
+#endif
+
+    size_t write(const char* data);
+    size_t write(const char* data, size_t size, uint8_t apiflags=0); //only when canSend() == true
+
+    uint8_t state();
+    bool connecting();
+    bool connected();
+    bool disconnecting();
+    bool disconnected();
+    bool freeable();//disconnected or disconnecting
+
+    uint16_t getMss();
+    uint32_t getRxTimeout();
+    void setRxTimeout(uint32_t timeout);//no RX data timeout for the connection in seconds
+    uint32_t getAckTimeout();
+    void setAckTimeout(uint32_t timeout);//no ACK timeout for the last sent packet in milliseconds
+    void setNoDelay(bool nodelay);
+    bool getNoDelay();
+    uint16_t getRemotePort();
+    uint16_t getLocalPort();
+
+    IPAddress remoteIP();
+    uint16_t  remotePort();
+    IPAddress localIP();
+    uint16_t  localPort();
+
+    void onConnect(AcConnectHandler cb, void* arg = 0);     //on successful connect
+    void onDisconnect(AcConnectHandler cb, void* arg = 0);  //disconnected
+    void onAck(AcAckHandler cb, void* arg = 0);             //ack received
+    void onError(AcErrorHandler cb, void* arg = 0);         //unsuccessful connect or error
+    void onData(AcDataHandler cb, void* arg = 0);           //data received (called if onPacket is not used)
+    void onPacket(AcPacketHandler cb, void* arg = 0);       //data received
+    void onTimeout(AcTimeoutHandler cb, void* arg = 0);     //ack timeout
+    void onPoll(AcConnectHandler cb, void* arg = 0);        //every 125ms when connected
+    void ackPacket(struct pbuf * pb);
+
+    const char * errorToString(err_t error);
+    const char * stateToString();
+
+    void _recv(std::shared_ptr<ACErrorTracker>& closeAbort, tcp_pcb* pcb, pbuf* pb, err_t err);
+    err_t getCloseError(void) const { return _errorTracker->getCloseError();}
+};
+
+#if ASYNC_TCP_SSL_ENABLED
+typedef std::function<int(void* arg, const char *filename, uint8_t **buf)> AcSSlFileHandler;
+struct pending_pcb;
+#endif
+
+
+class AsyncServer {
+  protected:
+    uint16_t _port;
+    IPAddress _addr;
+    bool _noDelay;
+    tcp_pcb* _pcb;
+    AcConnectHandler _connect_cb;
+    void* _connect_cb_arg;
+#if ASYNC_TCP_SSL_ENABLED
+    struct pending_pcb * _pending;
+    SSL_CTX * _ssl_ctx;
+    AcSSlFileHandler _file_cb;
+    void* _file_cb_arg;
+#endif
+#ifdef DEBUG_MORE
+    int _event_count[EE_MAX];
+#endif
+
+  public:
+
+    AsyncServer(IPAddress addr, uint16_t port);
+    AsyncServer(uint16_t port);
+    ~AsyncServer();
+    void onClient(AcConnectHandler cb, void* arg);
+#if ASYNC_TCP_SSL_ENABLED
+    void onSslFileRequest(AcSSlFileHandler cb, void* arg);
+    void beginSecure(const char *cert, const char *private_key_file, const char *password);
+#endif
+    void begin();
+    void end();
+    void setNoDelay(bool nodelay);
+    bool getNoDelay();
+    uint8_t status();
+#ifdef DEBUG_MORE
+    int getEventCount(size_t ee) const { return _event_count[ee];}
+#endif
+  protected:
+    err_t _accept(tcp_pcb* newpcb, err_t err);
+    static err_t _s_accept(void *arg, tcp_pcb* newpcb, err_t err);
+#ifdef DEBUG_MORE
+    int incEventCount(size_t ee) { return ++_event_count[ee];}
+#endif
+#if ASYNC_TCP_SSL_ENABLED
+    int _cert(const char *filename, uint8_t **buf);
+    err_t _poll(tcp_pcb* pcb);
+    err_t _recv(tcp_pcb *pcb, struct pbuf *pb, err_t err);
+    static int _s_cert(void *arg, const char *filename, uint8_t **buf);
+    static err_t _s_poll(void *arg, struct tcp_pcb *tpcb);
+    static err_t _s_recv(void *arg, struct tcp_pcb *tpcb, struct pbuf *pb, err_t err);
+#endif
+};
+
+
+#endif /* ASYNCTCP_H_ */

lib/ESPAsyncTCP-esphome/src/ESPAsyncTCPbuffer.cpp

@@ -0,0 +1,555 @@
+/**
+ * @file  ESPAsyncTCPbuffer.cpp
+ * @date  22.01.2016
+ * @author Markus Sattler
+ *
+ * Copyright (c) 2015 Markus Sattler. All rights reserved.
+ * This file is part of the Asynv TCP for ESP.
+ *
+ * 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
+ *
+ */
+
+
+#include <Arduino.h>
+#include <debug.h>
+
+#include "ESPAsyncTCPbuffer.h"
+
+
+AsyncTCPbuffer::AsyncTCPbuffer(AsyncClient* client) {
+    if(client == NULL) {
+        DEBUG_ASYNC_TCP("[A-TCP] client is null!!!\n");
+        panic();
+    }
+
+    _client = client;
+    _TXbufferWrite = new (std::nothrow) cbuf(TCP_MSS);
+    _TXbufferRead = _TXbufferWrite;
+    _RXbuffer = new (std::nothrow) cbuf(100);
+    _RXmode = ATB_RX_MODE_FREE;
+    _rxSize = 0;
+    _rxTerminator = 0x00;
+    _rxReadBytesPtr = NULL;
+    _rxReadStringPtr = NULL;
+    _cbDisconnect = NULL;
+
+    _cbRX = NULL;
+    _cbDone = NULL;
+    _attachCallbacks();
+}
+
+AsyncTCPbuffer::~AsyncTCPbuffer() {
+    if(_client) {
+        _client->close();
+    }
+
+    if(_RXbuffer) {
+        delete _RXbuffer;
+        _RXbuffer = NULL;
+    }
+
+    if(_TXbufferWrite) {
+        // will be deleted in _TXbufferRead chain
+        _TXbufferWrite = NULL;
+    }
+
+    if(_TXbufferRead) {
+        cbuf * next = _TXbufferRead->next;
+        delete _TXbufferRead;
+        while(next != NULL) {
+            _TXbufferRead = next;
+            next = _TXbufferRead->next;
+            delete _TXbufferRead;
+        }
+        _TXbufferRead = NULL;
+    }
+}
+
+size_t AsyncTCPbuffer::write(String & data) {
+    return write(data.c_str(), data.length());
+}
+
+size_t AsyncTCPbuffer::write(uint8_t data) {
+    return write(&data, 1);
+}
+
+size_t AsyncTCPbuffer::write(const char* data) {
+    return write((const uint8_t *) data, strlen(data));
+}
+
+size_t AsyncTCPbuffer::write(const char *data, size_t len) {
+    return write((const uint8_t *) data, len);
+}
+
+/**
+ * write data in to buffer and try to send the data
+ * @param data
+ * @param len
+ * @return
+ */
+size_t AsyncTCPbuffer::write(const uint8_t *data, size_t len) {
+    if(_TXbufferWrite == NULL || _client == NULL || !_client->connected() || data == NULL || len == 0) {
+        return 0;
+    }
+
+    size_t bytesLeft = len;
+    while(bytesLeft) {
+        size_t w = _TXbufferWrite->write((const char*) data, bytesLeft);
+        bytesLeft -= w;
+        data += w;
+        _sendBuffer();
+
+        // add new buffer since we have more data
+        if(_TXbufferWrite->full() && bytesLeft > 0) {
+
+            // to less ram!!!
+            if(ESP.getFreeHeap() < 4096) {
+                DEBUG_ASYNC_TCP("[A-TCP] run out of Heap can not send all Data!\n");
+                return (len - bytesLeft);
+            }
+
+            cbuf * next = new (std::nothrow) cbuf(TCP_MSS);
+            if(next == NULL) {
+                DEBUG_ASYNC_TCP("[A-TCP] run out of Heap!\n");
+                panic();
+            } else {
+                DEBUG_ASYNC_TCP("[A-TCP] new cbuf\n");
+            }
+
+            // add new buffer to chain (current cbuf)
+            _TXbufferWrite->next = next;
+
+            // move ptr for next data
+            _TXbufferWrite = next;
+        }
+    }
+
+    return len;
+
+}
+
+/**
+ * wait until all data has send out
+ */
+void AsyncTCPbuffer::flush() {
+    while(!_TXbufferWrite->empty()) {
+        while(connected() && !_client->canSend()) {
+          delay(0);
+        }
+        if(!connected())
+          return;
+        _sendBuffer();
+    }
+}
+
+void AsyncTCPbuffer::noCallback() {
+    _RXmode = ATB_RX_MODE_NONE;
+}
+
+void AsyncTCPbuffer::readStringUntil(char terminator, String * str, AsyncTCPbufferDoneCb done) {
+    if(_client == NULL) {
+        return;
+    }
+    DEBUG_ASYNC_TCP("[A-TCP] readStringUntil terminator: %02X\n", terminator);
+    _RXmode = ATB_RX_MODE_NONE;
+    _cbDone = done;
+    _rxReadStringPtr = str;
+    _rxTerminator = terminator;
+    _rxSize = 0;
+    _RXmode = ATB_RX_MODE_TERMINATOR_STRING;
+}
+
+/*
+ void AsyncTCPbuffer::readBytesUntil(char terminator, char *buffer, size_t length, AsyncTCPbufferDoneCb done) {
+ _RXmode = ATB_RX_MODE_NONE;
+ _cbDone = done;
+ _rxReadBytesPtr = (uint8_t *) buffer;
+ _rxTerminator = terminator;
+ _rxSize = length;
+ _RXmode = ATB_RX_MODE_TERMINATOR;
+ _handleRxBuffer(NULL, 0);
+ }
+
+ void AsyncTCPbuffer::readBytesUntil(char terminator, uint8_t *buffer, size_t length, AsyncTCPbufferDoneCb done) {
+ readBytesUntil(terminator, (char *) buffer, length, done);
+ }
+ */
+
+void AsyncTCPbuffer::readBytes(char *buffer, size_t length, AsyncTCPbufferDoneCb done) {
+    if(_client == NULL) {
+        return;
+    }
+    DEBUG_ASYNC_TCP("[A-TCP] readBytes length: %d\n", length);
+    _RXmode = ATB_RX_MODE_NONE;
+    _cbDone = done;
+    _rxReadBytesPtr = (uint8_t *) buffer;
+    _rxSize = length;
+    _RXmode = ATB_RX_MODE_READ_BYTES;
+}
+
+void AsyncTCPbuffer::readBytes(uint8_t *buffer, size_t length, AsyncTCPbufferDoneCb done) {
+    readBytes((char *) buffer, length, done);
+}
+
+void AsyncTCPbuffer::onData(AsyncTCPbufferDataCb cb) {
+    if(_client == NULL) {
+        return;
+    }
+    DEBUG_ASYNC_TCP("[A-TCP] onData\n");
+    _RXmode = ATB_RX_MODE_NONE;
+    _cbDone = NULL;
+    _cbRX = cb;
+    _RXmode = ATB_RX_MODE_FREE;
+}
+
+void AsyncTCPbuffer::onDisconnect(AsyncTCPbufferDisconnectCb cb) {
+    _cbDisconnect = cb;
+}
+
+IPAddress AsyncTCPbuffer::remoteIP() {
+    if(!_client) {
+        return IPAddress(0U);
+    }
+    return _client->remoteIP();
+}
+
+uint16_t AsyncTCPbuffer::remotePort() {
+    if(!_client) {
+        return 0;
+    }
+    return _client->remotePort();
+}
+
+bool AsyncTCPbuffer::connected() {
+    if(!_client) {
+        return false;
+    }
+    return _client->connected();
+}
+
+void AsyncTCPbuffer::stop() {
+
+    if(!_client) {
+        return;
+    }
+    _client->stop();
+    _client = NULL;
+
+    if(_cbDone) {
+        switch(_RXmode) {
+            case ATB_RX_MODE_READ_BYTES:
+            case ATB_RX_MODE_TERMINATOR:
+            case ATB_RX_MODE_TERMINATOR_STRING:
+                _RXmode = ATB_RX_MODE_NONE;
+                _cbDone(false, NULL);
+                break;
+            default:
+              break;
+        }
+    }
+    _RXmode = ATB_RX_MODE_NONE;
+}
+
+void AsyncTCPbuffer::close() {
+    stop();
+}
+
+
+///--------------------------------
+
+/**
+ * attachCallbacks to AsyncClient class
+ */
+void AsyncTCPbuffer::_attachCallbacks() {
+    if(!_client) {
+        return;
+    }
+    DEBUG_ASYNC_TCP("[A-TCP] attachCallbacks\n");
+
+    _client->onPoll([](void *obj, AsyncClient* c) {
+        (void)c;
+        AsyncTCPbuffer* b = ((AsyncTCPbuffer*)(obj));
+        if((b->_TXbufferRead != NULL) && !b->_TXbufferRead->empty()) {
+            b->_sendBuffer();
+        }
+        //    if(!b->_RXbuffer->empty()) {
+        //       b->_handleRxBuffer(NULL, 0);
+        //   }
+    }, this);
+
+    _client->onAck([](void *obj, AsyncClient* c, size_t len, uint32_t time) {
+        (void)c;
+        (void)len;
+        (void)time;
+        DEBUG_ASYNC_TCP("[A-TCP] onAck\n");
+        ((AsyncTCPbuffer*)(obj))->_sendBuffer();
+    }, this);
+
+    _client->onDisconnect([](void *obj, AsyncClient* c) {
+        DEBUG_ASYNC_TCP("[A-TCP] onDisconnect\n");
+        AsyncTCPbuffer* b = ((AsyncTCPbuffer*)(obj));
+        b->_client = NULL;
+        bool del = true;
+        if(b->_cbDisconnect) {
+            del = b->_cbDisconnect(b);
+        }
+        delete c;
+        if(del) {
+            delete b;
+        }
+    }, this);
+
+    _client->onData([](void *obj, AsyncClient* c, void *buf, size_t len) {
+        (void)c;
+        AsyncTCPbuffer* b = ((AsyncTCPbuffer*)(obj));
+        b->_rxData((uint8_t *)buf, len);
+    }, this);
+
+    _client->onTimeout([](void *obj, AsyncClient* c, uint32_t time){
+        (void)obj;
+        (void)time;
+        DEBUG_ASYNC_TCP("[A-TCP] onTimeout\n");
+        c->close();
+    }, this);
+
+    DEBUG_ASYNC_TCP("[A-TCP] attachCallbacks Done.\n");
+}
+
+/**
+ * send TX buffer if possible
+ */
+void AsyncTCPbuffer::_sendBuffer() {
+    //DEBUG_ASYNC_TCP("[A-TCP] _sendBuffer...\n");
+    size_t available = _TXbufferRead->available();
+    if(available == 0 || _client == NULL || !_client->connected() || !_client->canSend()) {
+        return;
+    }
+
+    while(connected() && (_client->space() > 0) && (_TXbufferRead->available() > 0) && _client->canSend()) {
+
+        available = _TXbufferRead->available();
+
+        if(available > _client->space()) {
+            available = _client->space();
+        }
+
+        char *out = new (std::nothrow) char[available];
+        if(out == NULL) {
+            DEBUG_ASYNC_TCP("[A-TCP] to less heap, try later.\n");
+            return;
+        }
+
+        // read data from buffer
+        _TXbufferRead->peek(out, available);
+
+        // send data
+        size_t send = _client->write((const char*) out, available);
+        if(send != available) {
+            DEBUG_ASYNC_TCP("[A-TCP] write failed send: %d available: %d \n", send, available);
+            if(!connected()) {
+                DEBUG_ASYNC_TCP("[A-TCP] incomplete transfer, connection lost.\n");
+            }
+        }
+
+        // remove really send data from buffer
+        _TXbufferRead->remove(send);
+
+        // if buffer is empty and there is a other buffer in chain delete the empty one
+        if(_TXbufferRead->available() == 0 && _TXbufferRead->next != NULL) {
+            cbuf * old = _TXbufferRead;
+            _TXbufferRead = _TXbufferRead->next;
+            delete old;
+            DEBUG_ASYNC_TCP("[A-TCP] delete cbuf\n");
+        }
+
+        delete out;
+    }
+
+}
+
+/**
+ * called on incoming data
+ * @param buf
+ * @param len
+ */
+void AsyncTCPbuffer::_rxData(uint8_t *buf, size_t len) {
+    if(!_client || !_client->connected()) {
+        DEBUG_ASYNC_TCP("[A-TCP] not connected!\n");
+        return;
+    }
+    if(!_RXbuffer) {
+        DEBUG_ASYNC_TCP("[A-TCP] _rxData no _RXbuffer!\n");
+        return;
+    }
+    DEBUG_ASYNC_TCP("[A-TCP] _rxData len: %d RXmode: %d\n", len, _RXmode);
+
+    size_t handled = 0;
+
+    if(_RXmode != ATB_RX_MODE_NONE) {
+        handled = _handleRxBuffer((uint8_t *) buf, len);
+        buf += handled;
+        len -= handled;
+
+        // handle as much as possible before using the buffer
+        if(_RXbuffer->empty()) {
+            while(_RXmode != ATB_RX_MODE_NONE && handled != 0 && len > 0) {
+                handled = _handleRxBuffer(buf, len);
+                buf += handled;
+                len -= handled;
+            }
+        }
+    }
+
+    if(len > 0) {
+
+        if(_RXbuffer->room() < len) {
+            // to less space
+            DEBUG_ASYNC_TCP("[A-TCP] _rxData buffer full try resize\n");
+            _RXbuffer->resizeAdd((len + _RXbuffer->room()));
+
+            if(_RXbuffer->room() < len) {
+                DEBUG_ASYNC_TCP("[A-TCP] _rxData buffer to full can only handle %d!!!\n", _RXbuffer->room());
+            }
+        }
+
+        _RXbuffer->write((const char *) (buf), len);
+    }
+
+    if(!_RXbuffer->empty() && _RXmode != ATB_RX_MODE_NONE) {
+        // handle as much as possible data in buffer
+        handled = _handleRxBuffer(NULL, 0);
+        while(_RXmode != ATB_RX_MODE_NONE && handled != 0) {
+            handled = _handleRxBuffer(NULL, 0);
+        }
+    }
+
+    // clean up ram
+    if(_RXbuffer->empty() && _RXbuffer->room() != 100) {
+        _RXbuffer->resize(100);
+    }
+
+}
+
+/**
+ *
+ */
+size_t AsyncTCPbuffer::_handleRxBuffer(uint8_t *buf, size_t len) {
+    if(!_client || !_client->connected() || _RXbuffer == NULL) {
+        return 0;
+    }
+
+    DEBUG_ASYNC_TCP("[A-TCP] _handleRxBuffer len: %d RXmode: %d\n", len, _RXmode);
+
+    size_t BufferAvailable = _RXbuffer->available();
+    size_t r = 0;
+
+    if(_RXmode == ATB_RX_MODE_NONE) {
+        return 0;
+    } else if(_RXmode == ATB_RX_MODE_FREE) {
+        if(_cbRX == NULL) {
+            return 0;
+        }
+
+        if(BufferAvailable > 0) {
+            uint8_t * b = new (std::nothrow) uint8_t[BufferAvailable];
+            if(b == NULL){
+              panic(); //TODO: What action should this be ?
+            }
+            _RXbuffer->peek((char *) b, BufferAvailable);
+            r = _cbRX(b, BufferAvailable);
+            _RXbuffer->remove(r);
+        }
+
+        if(r == BufferAvailable && buf && (len > 0)) {
+            return _cbRX(buf, len);
+        } else {
+            return 0;
+        }
+
+    } else if(_RXmode == ATB_RX_MODE_READ_BYTES) {
+        if(_rxReadBytesPtr == NULL || _cbDone == NULL) {
+            return 0;
+        }
+
+        size_t newReadCount = 0;
+
+        if(BufferAvailable) {
+            r = _RXbuffer->read((char *) _rxReadBytesPtr, _rxSize);
+            _rxSize -= r;
+            _rxReadBytesPtr += r;
+        }
+
+        if(_RXbuffer->empty() && (len > 0) && buf) {
+            r = len;
+            if(r > _rxSize) {
+                r = _rxSize;
+            }
+            memcpy(_rxReadBytesPtr, buf, r);
+            _rxReadBytesPtr += r;
+            _rxSize -= r;
+            newReadCount += r;
+        }
+
+        if(_rxSize == 0) {
+            _RXmode = ATB_RX_MODE_NONE;
+            _cbDone(true, NULL);
+        }
+
+        // add left over bytes to Buffer
+        return newReadCount;
+
+    } else if(_RXmode == ATB_RX_MODE_TERMINATOR) {
+        // TODO implement read terminator non string
+
+    } else if(_RXmode == ATB_RX_MODE_TERMINATOR_STRING) {
+        if(_rxReadStringPtr == NULL || _cbDone == NULL) {
+            return 0;
+        }
+
+        // handle Buffer
+        if(BufferAvailable > 0) {
+            while(!_RXbuffer->empty()) {
+                char c = _RXbuffer->read();
+                if(c == _rxTerminator || c == 0x00) {
+                    _RXmode = ATB_RX_MODE_NONE;
+                    _cbDone(true, _rxReadStringPtr);
+                    return 0;
+                } else {
+                    (*_rxReadStringPtr) += c;
+                }
+            }
+        }
+
+        if(_RXbuffer->empty() && (len > 0) && buf) {
+            size_t newReadCount = 0;
+            while(newReadCount < len) {
+                char c = (char) *buf;
+                buf++;
+                newReadCount++;
+                if(c == _rxTerminator || c == 0x00) {
+                    _RXmode = ATB_RX_MODE_NONE;
+                    _cbDone(true, _rxReadStringPtr);
+                    return newReadCount;
+                } else {
+                    (*_rxReadStringPtr) += c;
+                }
+            }
+            return newReadCount;
+        }
+    }
+
+    return 0;
+}

lib/ESPAsyncTCP-esphome/src/ESPAsyncTCPbuffer.h

@@ -0,0 +1,118 @@
+/**
+ * @file ESPAsyncTCPbuffer.h
+ * @date  22.01.2016
+ * @author Markus Sattler
+ *
+ * Copyright (c) 2015 Markus Sattler. All rights reserved.
+ * This file is part of the Asynv TCP for ESP.
+ *
+ * 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 ESPASYNCTCPBUFFER_H_
+#define ESPASYNCTCPBUFFER_H_
+
+//#define DEBUG_ASYNC_TCP(...)  while(((U0S >> USTXC) & 0x7F) != 0x00); os_printf( __VA_ARGS__ ); while(((U0S >> USTXC) & 0x7F) != 0x00)
+//#define DEBUG_ASYNC_TCP ASYNC_TCP_DEBUG
+#ifndef DEBUG_ASYNC_TCP
+#define DEBUG_ASYNC_TCP(...)
+#endif
+
+#include <Arduino.h>
+#include <cbuf.h>
+
+#include "ESPAsyncTCP.h"
+
+
+
+typedef enum {
+    ATB_RX_MODE_NONE,
+    ATB_RX_MODE_FREE,
+    ATB_RX_MODE_READ_BYTES,
+    ATB_RX_MODE_TERMINATOR,
+    ATB_RX_MODE_TERMINATOR_STRING
+} atbRxMode_t;
+
+class AsyncTCPbuffer: public Print {
+
+    public:
+
+        typedef std::function<size_t(uint8_t * payload, size_t length)> AsyncTCPbufferDataCb;
+        typedef std::function<void(bool ok, void * ret)> AsyncTCPbufferDoneCb;
+        typedef std::function<bool(AsyncTCPbuffer * obj)> AsyncTCPbufferDisconnectCb;
+
+        AsyncTCPbuffer(AsyncClient* c);
+        virtual ~AsyncTCPbuffer();
+
+        size_t write(String & data);
+        size_t write(uint8_t data);
+        size_t write(const char* data);
+        size_t write(const char *data, size_t len);
+        size_t write(const uint8_t *data, size_t len);
+
+        void flush();
+
+        void noCallback();
+
+        void readStringUntil(char terminator, String * str, AsyncTCPbufferDoneCb done);
+
+        // TODO implement read terminator non string
+        //void readBytesUntil(char terminator, char *buffer, size_t length, AsyncTCPbufferDoneCb done);
+        //void readBytesUntil(char terminator, uint8_t *buffer, size_t length, AsyncTCPbufferDoneCb done);
+
+        void readBytes(char *buffer, size_t length, AsyncTCPbufferDoneCb done);
+        void readBytes(uint8_t *buffer, size_t length, AsyncTCPbufferDoneCb done);
+
+        // TODO implement
+        // void setTimeout(size_t timeout);
+
+        void onData(AsyncTCPbufferDataCb cb);
+        void onDisconnect(AsyncTCPbufferDisconnectCb cb);
+
+        IPAddress remoteIP();
+        uint16_t  remotePort();
+        IPAddress localIP();
+        uint16_t  localPort();
+
+        bool connected();
+
+        void stop();
+        void close();
+
+    protected:
+        AsyncClient* _client;
+        cbuf * _TXbufferRead;
+        cbuf * _TXbufferWrite;
+        cbuf * _RXbuffer;
+        atbRxMode_t _RXmode;
+        size_t _rxSize;
+        char _rxTerminator;
+        uint8_t * _rxReadBytesPtr;
+        String * _rxReadStringPtr;
+
+        AsyncTCPbufferDataCb _cbRX;
+        AsyncTCPbufferDoneCb _cbDone;
+        AsyncTCPbufferDisconnectCb _cbDisconnect;
+
+        void _attachCallbacks();
+        void _sendBuffer();
+        void _on_close();
+        void _rxData(uint8_t *buf, size_t len);
+        size_t _handleRxBuffer(uint8_t *buf, size_t len);
+
+};
+
+#endif /* ESPASYNCTCPBUFFER_H_ */

lib/ESPAsyncTCP-esphome/src/SyncClient.cpp

@@ -0,0 +1,414 @@
+/*
+  Asynchronous TCP library for Espressif MCUs
+
+  Copyright (c) 2016 Hristo Gochkov. All rights reserved.
+  This file is part of the esp8266 core for Arduino environment.
+
+  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
+*/
+#include "Arduino.h"
+#include "SyncClient.h"
+#include "ESPAsyncTCP.h"
+#include "cbuf.h"
+#include <interrupts.h>
+
+#define DEBUG_ESP_SYNC_CLIENT
+#if defined(DEBUG_ESP_SYNC_CLIENT) && !defined(SYNC_CLIENT_DEBUG)
+#define SYNC_CLIENT_DEBUG( format, ...) DEBUG_GENERIC_P("[SYNC_CLIENT]", format, ##__VA_ARGS__)
+#endif
+#ifndef SYNC_CLIENT_DEBUG
+#define SYNC_CLIENT_DEBUG(...) do { (void)0;} while(false)
+#endif
+
+/*
+  Without LWIP_NETIF_TX_SINGLE_PBUF, all tcp_writes default to "no copy".
+  Referenced data must be preserved and free-ed from the specified tcp_sent()
+  callback. Alternative, tcp_writes need to use the TCP_WRITE_FLAG_COPY
+  attribute.
+*/
+static_assert(LWIP_NETIF_TX_SINGLE_PBUF, "Required, tcp_write() must always copy.");
+
+SyncClient::SyncClient(size_t txBufLen)
+  : _client(NULL)
+  , _tx_buffer(NULL)
+  , _tx_buffer_size(txBufLen)
+  , _rx_buffer(NULL)
+  , _ref(NULL)
+{
+  ref();
+}
+
+SyncClient::SyncClient(AsyncClient *client, size_t txBufLen)
+  : _client(client)
+  , _tx_buffer(new (std::nothrow) cbuf(txBufLen))
+  , _tx_buffer_size(txBufLen)
+  , _rx_buffer(NULL)
+  , _ref(NULL)
+{
+  if(ref() > 0 && _client != NULL)
+    _attachCallbacks();
+}
+
+SyncClient::~SyncClient(){
+  if (0 == unref())
+    _release();
+}
+
+void SyncClient::_release(){
+  if(_client != NULL){
+    _client->onData(NULL, NULL);
+    _client->onAck(NULL, NULL);
+    _client->onPoll(NULL, NULL);
+    _client->abort();
+    _client = NULL;
+  }
+  if(_tx_buffer != NULL){
+    cbuf *b = _tx_buffer;
+    _tx_buffer = NULL;
+    delete b;
+  }
+  while(_rx_buffer != NULL){
+    cbuf *b = _rx_buffer;
+    _rx_buffer = _rx_buffer->next;
+    delete b;
+  }
+}
+
+int SyncClient::ref(){
+  if(_ref == NULL){
+    _ref = new (std::nothrow) int;
+    if(_ref != NULL)
+      *_ref = 0;
+    else
+      return -1;
+  }
+  return (++*_ref);
+}
+
+int SyncClient::unref(){
+  int count = -1;
+  if (_ref != NULL) {
+    count = --*_ref;
+    if (0 == count) {
+      delete _ref;
+      _ref = NULL;
+    }
+  }
+  return count;
+}
+
+#if ASYNC_TCP_SSL_ENABLED
+int SyncClient::_connect(const IPAddress& ip, uint16_t port, bool secure){
+#else
+int SyncClient::_connect(const IPAddress& ip, uint16_t port){
+#endif
+  if(connected())
+    return 0;
+  if(_client != NULL)
+    delete _client;
+
+  _client = new (std::nothrow) AsyncClient();
+  if (_client == NULL)
+    return 0;
+
+  _client->onConnect([](void *obj, AsyncClient *c){ ((SyncClient*)(obj))->_onConnect(c); }, this);
+  _attachCallbacks_Disconnect();
+#if ASYNC_TCP_SSL_ENABLED
+  if(_client->connect(ip, port, secure)){
+#else
+  if(_client->connect(ip, port)){
+#endif
+    while(_client != NULL && !_client->connected() && !_client->disconnecting())
+      delay(1);
+    return connected();
+  }
+  return 0;
+}
+
+#if ASYNC_TCP_SSL_ENABLED
+int SyncClient::connect(const char *host, uint16_t port, bool secure){
+#else
+int SyncClient::connect(const char *host, uint16_t port){
+#endif
+  if(connected())
+    return 0;
+  if(_client != NULL)
+    delete _client;
+
+  _client = new (std::nothrow) AsyncClient();
+  if (_client == NULL)
+    return 0;
+
+  _client->onConnect([](void *obj, AsyncClient *c){ ((SyncClient*)(obj))->_onConnect(c); }, this);
+  _attachCallbacks_Disconnect();
+#if ASYNC_TCP_SSL_ENABLED
+  if(_client->connect(host, port, secure)){
+#else
+  if(_client->connect(host, port)){
+#endif
+    while(_client != NULL && !_client->connected() && !_client->disconnecting())
+      delay(1);
+    return connected();
+  }
+  return 0;
+}
+//#define SYNCCLIENT_NEW_OPERATOR_EQUAL
+#ifdef SYNCCLIENT_NEW_OPERATOR_EQUAL
+/*
+  New behavior for operator=
+
+  Allow for the object to be placed on a queue and transfered to a new container
+  with buffers still in tact. Avoiding receive data drops. Transfers rx and tx
+  buffers. Supports return by value.
+
+  Note, this is optional, the old behavior is the default.
+
+*/
+SyncClient & SyncClient::operator=(const SyncClient &other){
+  int *rhsref = other._ref;
+  ++*rhsref; // Just in case the left and right side are the same object with different containers
+  if (0 == unref())
+    _release();
+  _ref = other._ref;
+  ref();
+  --*rhsref;
+  // Why do I not test _tx_buffer for != NULL and free?
+  // I allow for the lh target container, to be a copy of an active
+  // connection. Thus we are just reusing the container.
+  // The above unref() handles releaseing the previous client of the container.
+  _tx_buffer_size = other._tx_buffer_size;
+  _tx_buffer = other._tx_buffer;
+  _client = other._client;
+  if (_client != NULL && _tx_buffer == NULL)
+    _tx_buffer = new (std::nothrow) cbuf(_tx_buffer_size);
+
+  _rx_buffer = other._rx_buffer;
+  if(_client)
+    _attachCallbacks();
+  return *this;
+}
+#else   // ! SYNCCLIENT_NEW_OPERATOR_EQUAL
+// This is the origianl logic with null checks
+SyncClient & SyncClient::operator=(const SyncClient &other){
+  if(_client != NULL){
+    _client->abort();
+    _client->free();
+    _client = NULL;
+  }
+  _tx_buffer_size = other._tx_buffer_size;
+  if(_tx_buffer != NULL){
+    cbuf *b = _tx_buffer;
+    _tx_buffer = NULL;
+    delete b;
+  }
+  while(_rx_buffer != NULL){
+    cbuf *b = _rx_buffer;
+    _rx_buffer = b->next;
+    delete b;
+  }
+  if(other._client != NULL)
+    _tx_buffer = new (std::nothrow) cbuf(other._tx_buffer_size);
+
+  _client = other._client;
+  if(_client)
+    _attachCallbacks();
+
+  return *this;
+}
+#endif
+
+void SyncClient::setTimeout(uint32_t seconds){
+  if(_client != NULL)
+    _client->setRxTimeout(seconds);
+}
+
+uint8_t SyncClient::status(){
+  if(_client == NULL)
+    return 0;
+  return _client->state();
+}
+
+uint8_t SyncClient::connected(){
+  return (_client != NULL && _client->connected());
+}
+
+bool SyncClient::stop(unsigned int maxWaitMs){
+  (void)maxWaitMs;
+  if(_client != NULL)
+    _client->close(true);
+  return true;
+}
+
+size_t SyncClient::_sendBuffer(){
+  if(_client == NULL || _tx_buffer == NULL)
+    return 0;
+  size_t available = _tx_buffer->available();
+  if(!connected() || !_client->canSend() || available == 0)
+    return 0;
+  size_t sendable = _client->space();
+  if(sendable < available)
+    available= sendable;
+  char *out = new (std::nothrow) char[available];
+  if(out == NULL)
+    return 0;
+
+  _tx_buffer->read(out, available);
+  size_t sent = _client->write(out, available);
+  delete[] out;
+  return sent;
+}
+
+void SyncClient::_onData(void *data, size_t len){
+  _client->ackLater();
+  cbuf *b = new (std::nothrow) cbuf(len+1);
+  if(b != NULL){
+    b->write((const char *)data, len);
+    if(_rx_buffer == NULL)
+      _rx_buffer = b;
+    else {
+      cbuf *p = _rx_buffer;
+      while(p->next != NULL)
+        p = p->next;
+      p->next = b;
+    }
+  } else {
+    // We ran out of memory. This fail causes lost receive data.
+    // The connection should be closed in a manner that conveys something
+    // bad/abnormal has happened to the connection. Hence, we abort the
+    // connection to avoid possible data corruption.
+    // Note, callbacks maybe called.
+    _client->abort();
+  }
+}
+
+void SyncClient::_onDisconnect(){
+  if(_client != NULL){
+    _client = NULL;
+  }
+  if(_tx_buffer != NULL){
+    cbuf *b = _tx_buffer;
+    _tx_buffer = NULL;
+    delete b;
+  }
+}
+
+void SyncClient::_onConnect(AsyncClient *c){
+  _client = c;
+  if(_tx_buffer != NULL){
+    cbuf *b = _tx_buffer;
+    _tx_buffer = NULL;
+    delete b;
+  }
+  _tx_buffer = new (std::nothrow) cbuf(_tx_buffer_size);
+  _attachCallbacks_AfterConnected();
+}
+
+void SyncClient::_attachCallbacks(){
+  _attachCallbacks_Disconnect();
+  _attachCallbacks_AfterConnected();
+}
+
+void SyncClient::_attachCallbacks_AfterConnected(){
+  _client->onAck([](void *obj, AsyncClient* c, size_t len, uint32_t time){ (void)c; (void)len; (void)time; ((SyncClient*)(obj))->_sendBuffer(); }, this);
+  _client->onData([](void *obj, AsyncClient* c, void *data, size_t len){ (void)c; ((SyncClient*)(obj))->_onData(data, len); }, this);
+  _client->onTimeout([](void *obj, AsyncClient* c, uint32_t time){ (void)obj; (void)time; c->close(); }, this);
+}
+
+void SyncClient::_attachCallbacks_Disconnect(){
+  _client->onDisconnect([](void *obj, AsyncClient* c){ ((SyncClient*)(obj))->_onDisconnect(); delete c; }, this);
+}
+
+size_t SyncClient::write(uint8_t data){
+  return write(&data, 1);
+}
+
+size_t SyncClient::write(const uint8_t *data, size_t len){
+  if(_tx_buffer == NULL || !connected()){
+    return 0;
+  }
+  size_t toWrite = 0;
+  size_t toSend = len;
+  while(_tx_buffer->room() < toSend){
+    toWrite = _tx_buffer->room();
+    _tx_buffer->write((const char*)data, toWrite);
+    while(connected() && !_client->canSend())
+      delay(0);
+    if(!connected())
+      return 0;
+    _sendBuffer();
+    toSend -= toWrite;
+  }
+  _tx_buffer->write((const char*)(data+(len - toSend)), toSend);
+  if(connected() && _client->canSend())
+    _sendBuffer();
+  return len;
+}
+
+int SyncClient::available(){
+  if(_rx_buffer == NULL) return 0;
+  size_t a = 0;
+  cbuf *b = _rx_buffer;
+  while(b != NULL){
+    a += b->available();
+    b = b->next;
+  }
+  return a;
+}
+
+int SyncClient::peek(){
+  if(_rx_buffer == NULL) return -1;
+  return _rx_buffer->peek();
+}
+
+int SyncClient::read(uint8_t *data, size_t len){
+  if(_rx_buffer == NULL) return -1;
+
+  size_t readSoFar = 0;
+  while(_rx_buffer != NULL && (len - readSoFar) >= _rx_buffer->available()){
+    cbuf *b = _rx_buffer;
+    _rx_buffer = _rx_buffer->next;
+    size_t toRead = b->available();
+    readSoFar += b->read((char*)(data+readSoFar), toRead);
+    if(connected()){
+        _client->ack(b->size() - 1);
+    }
+    delete b;
+  }
+  if(_rx_buffer != NULL && readSoFar < len){
+    readSoFar += _rx_buffer->read((char*)(data+readSoFar), (len - readSoFar));
+  }
+  return readSoFar;
+}
+
+int SyncClient::read(){
+  uint8_t res = 0;
+  if(read(&res, 1) != 1)
+    return -1;
+  return res;
+}
+
+bool SyncClient::flush(unsigned int maxWaitMs){
+  (void)maxWaitMs;
+  if(_tx_buffer == NULL || !connected())
+    return false;
+  if(_tx_buffer->available()){
+    while(connected() && !_client->canSend())
+      delay(0);
+    if(_client == NULL || _tx_buffer == NULL)
+      return false;
+    _sendBuffer();
+  }
+  return true;
+}

lib/ESPAsyncTCP-esphome/src/SyncClient.h

@@ -0,0 +1,109 @@
+/*
+  Asynchronous TCP library for Espressif MCUs
+
+  Copyright (c) 2016 Hristo Gochkov. All rights reserved.
+  This file is part of the esp8266 core for Arduino environment.
+
+  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 SYNCCLIENT_H_
+#define SYNCCLIENT_H_
+
+#include "Client.h"
+// Needed for Arduino core releases prior to 2.5.0, because of changes
+// made to accommodate Arduino core 2.5.0
+// CONST was 1st defined in Core 2.5.0 in IPAddress.h
+#ifndef CONST
+#define CONST
+#endif
+#include <async_config.h>
+class cbuf;
+class AsyncClient;
+
+class SyncClient: public Client {
+  private:
+    AsyncClient *_client;
+    cbuf *_tx_buffer;
+    size_t _tx_buffer_size;
+    cbuf *_rx_buffer;
+    int *_ref;
+
+    size_t _sendBuffer();
+    void _onData(void *data, size_t len);
+    void _onConnect(AsyncClient *c);
+    void _onDisconnect();
+    void _attachCallbacks();
+    void _attachCallbacks_Disconnect();
+    void _attachCallbacks_AfterConnected();
+    void _release();
+
+  public:
+    SyncClient(size_t txBufLen = TCP_MSS);
+    SyncClient(AsyncClient *client, size_t txBufLen = TCP_MSS);
+    virtual ~SyncClient();
+
+    int ref();
+    int unref();
+    operator bool(){ return connected(); }
+    SyncClient & operator=(const SyncClient &other);
+
+#if ASYNC_TCP_SSL_ENABLED
+    int _connect(const IPAddress& ip, uint16_t port, bool secure);
+    int connect(CONST IPAddress& ip, uint16_t port, bool secure){
+      return _connect(ip, port, secure);
+    }
+    int connect(IPAddress ip, uint16_t port, bool secure){
+      return _connect(reinterpret_cast<const IPAddress&>(ip), port, secure);
+    }
+    int connect(const char *host, uint16_t port, bool secure);
+    int connect(CONST IPAddress& ip, uint16_t port){
+      return _connect(ip, port, false);
+    }
+    int connect(IPAddress ip, uint16_t port){
+      return _connect(reinterpret_cast<const IPAddress&>(ip), port, false);
+    }
+    int connect(const char *host, uint16_t port){
+      return connect(host, port, false);
+    }
+#else
+    int _connect(const IPAddress& ip, uint16_t port);
+    int connect(CONST IPAddress& ip, uint16_t port){
+      return _connect(ip, port);
+    }
+    int connect(IPAddress ip, uint16_t port){
+      return _connect(reinterpret_cast<const IPAddress&>(ip), port);
+    }
+    int connect(const char *host, uint16_t port);
+#endif
+    void setTimeout(uint32_t seconds);
+
+    uint8_t status();
+    uint8_t connected();
+
+    bool stop(unsigned int maxWaitMs);
+    bool flush(unsigned int maxWaitMs);
+    void stop() { (void)stop(0);}
+    void flush() { (void)flush(0);}
+    size_t write(uint8_t data);
+    size_t write(const uint8_t *data, size_t len);
+
+    int available();
+    int peek();
+    int read();
+    int read(uint8_t *data, size_t len);
+};
+
+#endif /* SYNCCLIENT_H_ */

lib/ESPAsyncTCP-esphome/src/async_config.h

@@ -0,0 +1,42 @@
+#ifndef LIBRARIES_ESPASYNCTCP_SRC_ASYNC_CONFIG_H_
+#define LIBRARIES_ESPASYNCTCP_SRC_ASYNC_CONFIG_H_
+
+#ifndef ASYNC_TCP_SSL_ENABLED
+#define ASYNC_TCP_SSL_ENABLED 0
+#endif
+
+#ifndef TCP_MSS
+// May have been definded as a -DTCP_MSS option on the compile line or not.
+// Arduino core 2.3.0 or earlier does not do the -DTCP_MSS option.
+// Later versions may set this option with info from board.txt.
+// However, Core 2.4.0 and up board.txt does not define TCP_MSS for lwIP v1.4
+#define TCP_MSS (1460)
+#endif
+
+// #define ASYNC_TCP_DEBUG(...) ets_printf(__VA_ARGS__)
+// #define TCP_SSL_DEBUG(...) ets_printf(__VA_ARGS__)
+// #define ASYNC_TCP_ASSERT( a ) do{ if(!(a)){ets_printf("ASSERT: %s %u \n", __FILE__, __LINE__);}}while(0)
+
+// Starting with Arduino Core 2.4.0 and up the define of DEBUG_ESP_PORT
+// can be handled through the Arduino IDE Board options instead of here.
+// #define DEBUG_ESP_PORT Serial
+// #define DEBUG_ESP_ASYNC_TCP 1
+// #define DEBUG_ESP_TCP_SSL 1
+
+#ifndef DEBUG_SKIP__DEBUG_PRINT_MACROS
+
+#include <DebugPrintMacros.h>
+
+#ifndef ASYNC_TCP_ASSERT
+#define ASYNC_TCP_ASSERT(...) do { (void)0;} while(false)
+#endif
+#ifndef ASYNC_TCP_DEBUG
+#define ASYNC_TCP_DEBUG(...) do { (void)0;} while(false)
+#endif
+#ifndef TCP_SSL_DEBUG
+#define TCP_SSL_DEBUG(...) do { (void)0;} while(false)
+#endif
+
+#endif
+
+#endif /* LIBRARIES_ESPASYNCTCP_SRC_ASYNC_CONFIG_H_ */

lib/ESPAsyncTCP-esphome/src/tcp_axtls.c

@@ -0,0 +1,613 @@
+/*
+  Asynchronous TCP library for Espressif MCUs
+
+  Copyright (c) 2016 Hristo Gochkov. All rights reserved.
+  This file is part of the esp8266 core for Arduino environment.
+
+  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
+*/
+/*
+ * Compatibility for AxTLS with LWIP raw tcp mode (http://lwip.wikia.com/wiki/Raw/TCP)
+ * Original Code and Inspiration: Slavey Karadzhov
+ */
+
+// To handle all the definitions needed for debug printing, we need to delay
+// macro definitions till later.
+#define DEBUG_SKIP__DEBUG_PRINT_MACROS 1
+#include <async_config.h>
+#undef DEBUG_SKIP__DEBUG_PRINT_MACROS
+
+#if ASYNC_TCP_SSL_ENABLED
+
+#include "lwip/opt.h"
+#include "lwip/tcp.h"
+#include "lwip/inet.h"
+#include <stdlib.h>
+#include <stdint.h>
+#include <stdarg.h>
+#include <stdbool.h>
+#include <tcp_axtls.h>
+
+// ets_uart_printf is defined in esp8266_undocumented.h, in newer Arduino ESP8266 Core.
+extern int ets_uart_printf(const char *format, ...) __attribute__ ((format (printf, 1, 2)));
+#include <DebugPrintMacros.h>
+#ifndef TCP_SSL_DEBUG
+#define TCP_SSL_DEBUG(...) do { (void)0;} while(false)
+#endif
+
+uint8_t * default_private_key = NULL;
+uint16_t default_private_key_len = 0;
+
+uint8_t * default_certificate = NULL;
+uint16_t default_certificate_len = 0;
+
+static uint8_t _tcp_ssl_has_client = 0;
+
+SSL_CTX * tcp_ssl_new_server_ctx(const char *cert, const char *private_key_file, const char *password){
+  uint32_t options = SSL_CONNECT_IN_PARTS;
+  SSL_CTX *ssl_ctx;
+
+  if(private_key_file){
+    options |= SSL_NO_DEFAULT_KEY;
+  }
+
+  if ((ssl_ctx = ssl_ctx_new(options, SSL_DEFAULT_SVR_SESS)) == NULL){
+    TCP_SSL_DEBUG("tcp_ssl_new_server_ctx: failed to allocate context\n");
+    return NULL;
+  }
+
+  if (private_key_file){
+    int obj_type = SSL_OBJ_RSA_KEY;
+    if (strstr(private_key_file, ".p8"))
+      obj_type = SSL_OBJ_PKCS8;
+    else if (strstr(private_key_file, ".p12"))
+      obj_type = SSL_OBJ_PKCS12;
+
+    if (ssl_obj_load(ssl_ctx, obj_type, private_key_file, password)){
+      TCP_SSL_DEBUG("tcp_ssl_new_server_ctx: load private key '%s' failed\n", private_key_file);
+      return NULL;
+    }
+  }
+
+  if (cert){
+    if (ssl_obj_load(ssl_ctx, SSL_OBJ_X509_CERT, cert, NULL)){
+      TCP_SSL_DEBUG("tcp_ssl_new_server_ctx: load certificate '%s' failed\n", cert);
+      return NULL;
+    }
+  }
+  return ssl_ctx;
+}
+
+struct tcp_ssl_pcb {
+  struct tcp_pcb *tcp;
+  int fd;
+  SSL_CTX* ssl_ctx;
+  SSL *ssl;
+  uint8_t type;
+  int handshake;
+  void * arg;
+  tcp_ssl_data_cb_t on_data;
+  tcp_ssl_handshake_cb_t on_handshake;
+  tcp_ssl_error_cb_t on_error;
+  int last_wr;
+  struct pbuf *tcp_pbuf;
+  int pbuf_offset;
+  struct tcp_ssl_pcb * next;
+};
+
+typedef struct tcp_ssl_pcb tcp_ssl_t;
+
+static tcp_ssl_t * tcp_ssl_array = NULL;
+static int tcp_ssl_next_fd = 0;
+
+uint8_t tcp_ssl_has_client(){
+  return _tcp_ssl_has_client;
+}
+
+tcp_ssl_t * tcp_ssl_new(struct tcp_pcb *tcp) {
+
+  if(tcp_ssl_next_fd < 0){
+    tcp_ssl_next_fd = 0;//overflow
+  }
+
+  tcp_ssl_t * new_item = (tcp_ssl_t*)malloc(sizeof(tcp_ssl_t));
+  if(!new_item){
+    TCP_SSL_DEBUG("tcp_ssl_new: failed to allocate tcp_ssl\n");
+    return NULL;
+  }
+
+  new_item->tcp = tcp;
+  new_item->handshake = SSL_NOT_OK;
+  new_item->arg = NULL;
+  new_item->on_data = NULL;
+  new_item->on_handshake = NULL;
+  new_item->on_error = NULL;
+  new_item->tcp_pbuf = NULL;
+  new_item->pbuf_offset = 0;
+  new_item->next = NULL;
+  new_item->ssl_ctx = NULL;
+  new_item->ssl = NULL;
+  new_item->type = TCP_SSL_TYPE_CLIENT;
+  new_item->fd = tcp_ssl_next_fd++;
+
+  if(tcp_ssl_array == NULL){
+    tcp_ssl_array = new_item;
+  } else {
+    tcp_ssl_t * item = tcp_ssl_array;
+    while(item->next != NULL)
+      item = item->next;
+    item->next = new_item;
+  }
+
+  TCP_SSL_DEBUG("tcp_ssl_new: %d\n", new_item->fd);
+  return new_item;
+}
+
+tcp_ssl_t* tcp_ssl_get(struct tcp_pcb *tcp) {
+  if(tcp == NULL) {
+    return NULL;
+  }
+  tcp_ssl_t * item = tcp_ssl_array;
+  while(item && item->tcp != tcp){
+    item = item->next;
+  }
+  return item;
+}
+
+int tcp_ssl_new_client(struct tcp_pcb *tcp){
+  SSL_CTX* ssl_ctx;
+  tcp_ssl_t * tcp_ssl;
+
+  if(tcp == NULL) {
+    return -1;
+  }
+
+  if(tcp_ssl_get(tcp) != NULL){
+    TCP_SSL_DEBUG("tcp_ssl_new_client: tcp_ssl already exists\n");
+    return -1;
+  }
+
+  ssl_ctx = ssl_ctx_new(SSL_CONNECT_IN_PARTS | SSL_SERVER_VERIFY_LATER, 1);
+  if(ssl_ctx == NULL){
+    TCP_SSL_DEBUG("tcp_ssl_new_client: failed to allocate ssl context\n");
+    return -1;
+  }
+
+  tcp_ssl = tcp_ssl_new(tcp);
+  if(tcp_ssl == NULL){
+    ssl_ctx_free(ssl_ctx);
+    return -1;
+  }
+
+  tcp_ssl->ssl_ctx = ssl_ctx;
+
+  tcp_ssl->ssl = ssl_client_new(ssl_ctx, tcp_ssl->fd, NULL, 0, NULL);
+  if(tcp_ssl->ssl == NULL){
+    TCP_SSL_DEBUG("tcp_ssl_new_client: failed to allocate ssl\n");
+    tcp_ssl_free(tcp);
+    return -1;
+  }
+
+  return tcp_ssl->fd;
+}
+
+int tcp_ssl_new_server(struct tcp_pcb *tcp, SSL_CTX* ssl_ctx){
+  tcp_ssl_t * tcp_ssl;
+
+  if(tcp == NULL) {
+    return -1;
+  }
+
+  if(ssl_ctx == NULL){
+    return -1;
+  }
+
+  if(tcp_ssl_get(tcp) != NULL){
+    TCP_SSL_DEBUG("tcp_ssl_new_server: tcp_ssl already exists\n");
+    return -1;
+  }
+
+  tcp_ssl = tcp_ssl_new(tcp);
+  if(tcp_ssl == NULL){
+    return -1;
+  }
+
+  tcp_ssl->type = TCP_SSL_TYPE_SERVER;
+  tcp_ssl->ssl_ctx = ssl_ctx;
+
+  _tcp_ssl_has_client = 1;
+  tcp_ssl->ssl = ssl_server_new(ssl_ctx, tcp_ssl->fd);
+  if(tcp_ssl->ssl == NULL){
+    TCP_SSL_DEBUG("tcp_ssl_new_server: failed to allocate ssl\n");
+    tcp_ssl_free(tcp);
+    return -1;
+  }
+
+  return tcp_ssl->fd;
+}
+
+int tcp_ssl_free(struct tcp_pcb *tcp) {
+
+  if(tcp == NULL) {
+    return -1;
+  }
+
+  tcp_ssl_t * item = tcp_ssl_array;
+
+  if(item->tcp == tcp){
+    tcp_ssl_array = tcp_ssl_array->next;
+    if(item->tcp_pbuf != NULL){
+      pbuf_free(item->tcp_pbuf);
+    }
+    TCP_SSL_DEBUG("tcp_ssl_free: %d\n", item->fd);
+    if(item->ssl)
+      ssl_free(item->ssl);
+    if(item->type == TCP_SSL_TYPE_CLIENT && item->ssl_ctx)
+      ssl_ctx_free(item->ssl_ctx);
+    if(item->type == TCP_SSL_TYPE_SERVER)
+      _tcp_ssl_has_client = 0;
+    free(item);
+    return 0;
+  }
+
+  while(item->next && item->next->tcp != tcp)
+    item = item->next;
+
+  if(item->next == NULL){
+    return ERR_TCP_SSL_INVALID_CLIENTFD_DATA;//item not found
+  }
+
+  tcp_ssl_t * i = item->next;
+  item->next = i->next;
+  if(i->tcp_pbuf != NULL){
+    pbuf_free(i->tcp_pbuf);
+  }
+  TCP_SSL_DEBUG("tcp_ssl_free: %d\n", i->fd);
+  if(i->ssl)
+    ssl_free(i->ssl);
+  if(i->type == TCP_SSL_TYPE_CLIENT && i->ssl_ctx)
+    ssl_ctx_free(i->ssl_ctx);
+  if(i->type == TCP_SSL_TYPE_SERVER)
+    _tcp_ssl_has_client = 0;
+  free(i);
+  return 0;
+}
+
+#ifdef AXTLS_2_0_0_SNDBUF
+int tcp_ssl_sndbuf(struct tcp_pcb *tcp){
+  int expected;
+  int available;
+  int result = -1;
+
+  if(tcp == NULL) {
+    return result;
+  }
+  tcp_ssl_t * tcp_ssl = tcp_ssl_get(tcp);
+  if(!tcp_ssl){
+    TCP_SSL_DEBUG("tcp_ssl_sndbuf: tcp_ssl is NULL\n");
+    return result;
+  }
+  available = tcp_sndbuf(tcp);
+  if(!available){
+    TCP_SSL_DEBUG("tcp_ssl_sndbuf: tcp_sndbuf is zero\n");
+    return 0;
+  }
+  result = available;
+  while((expected = ssl_calculate_write_length(tcp_ssl->ssl, result)) > available){
+    result -= (expected - available) + 4;
+  }
+
+  if(expected > 0){
+    //TCP_SSL_DEBUG("tcp_ssl_sndbuf: tcp_sndbuf is %d from %d\n", result, available);
+    return result;
+  }
+
+  return 0;
+}
+#endif
+
+int tcp_ssl_write(struct tcp_pcb *tcp, uint8_t *data, size_t len) {
+  if(tcp == NULL) {
+    return -1;
+  }
+  tcp_ssl_t * tcp_ssl = tcp_ssl_get(tcp);
+  if(!tcp_ssl){
+    TCP_SSL_DEBUG("tcp_ssl_write: tcp_ssl is NULL\n");
+    return 0;
+  }
+  tcp_ssl->last_wr = 0;
+
+#ifdef AXTLS_2_0_0_SNDBUF
+  int expected_len = ssl_calculate_write_length(tcp_ssl->ssl, len);
+  int available_len = tcp_sndbuf(tcp);
+  if(expected_len < 0 || expected_len > available_len){
+    TCP_SSL_DEBUG("tcp_ssl_write: data will not fit! %u < %d(%u)\r\n", available_len, expected_len, len);
+    return -1;
+  }
+#endif
+
+  int rc = ssl_write(tcp_ssl->ssl, data, len);
+
+  //TCP_SSL_DEBUG("tcp_ssl_write: %u -> %d (%d)\r\n", len, tcp_ssl->last_wr, rc);
+
+  if (rc < 0){
+    if(rc != SSL_CLOSE_NOTIFY) {
+      TCP_SSL_DEBUG("tcp_ssl_write error: %d\r\n", rc);
+    }
+    return rc;
+  }
+
+  return tcp_ssl->last_wr;
+}
+
+/**
+ * Reads data from the SSL over TCP stream. Returns decrypted data.
+ * @param tcp_pcb *tcp - pointer to the raw tcp object
+ * @param pbuf *p - pointer to the buffer with the TCP packet data
+ *
+ * @return int
+ *      0 - when everything is fine but there are no symbols to process yet
+ *      < 0 - when there is an error
+ *      > 0 - the length of the clear text characters that were read
+ */
+int tcp_ssl_read(struct tcp_pcb *tcp, struct pbuf *p) {
+  if(tcp == NULL) {
+    return -1;
+  }
+  tcp_ssl_t* fd_data = NULL;
+
+  int read_bytes = 0;
+  int total_bytes = 0;
+  uint8_t *read_buf;
+
+  fd_data = tcp_ssl_get(tcp);
+  if(fd_data == NULL) {
+    TCP_SSL_DEBUG("tcp_ssl_read: tcp_ssl is NULL\n");
+    return ERR_TCP_SSL_INVALID_CLIENTFD_DATA;
+  }
+
+  if(p == NULL) {
+    TCP_SSL_DEBUG("tcp_ssl_read:p == NULL\n");
+    return ERR_TCP_SSL_INVALID_DATA;
+  }
+
+  //TCP_SSL_DEBUG("READY TO READ SOME DATA\n");
+
+  fd_data->tcp_pbuf = p;
+  fd_data->pbuf_offset = 0;
+
+  do {
+    read_bytes = ssl_read(fd_data->ssl, &read_buf);
+    TCP_SSL_DEBUG("tcp_ssl_ssl_read: %d\n", read_bytes);
+
+    if(read_bytes < SSL_OK) {
+      if(read_bytes != SSL_CLOSE_NOTIFY) {
+        TCP_SSL_DEBUG("tcp_ssl_read: read error: %d\n", read_bytes);
+      }
+      total_bytes = read_bytes;
+      break;
+    } else if(read_bytes > 0){
+      if(fd_data->on_data){
+        fd_data->on_data(fd_data->arg, tcp, read_buf, read_bytes);
+        // fd_data may have been freed in callback
+        fd_data = tcp_ssl_get(tcp);
+        if(NULL == fd_data)
+          return SSL_CLOSE_NOTIFY;
+      }
+      total_bytes+= read_bytes;
+    } else {
+      if(fd_data->handshake != SSL_OK) {
+        // fd_data may be freed in callbacks.
+        int handshake = fd_data->handshake = ssl_handshake_status(fd_data->ssl);
+        if(handshake == SSL_OK){
+          TCP_SSL_DEBUG("tcp_ssl_read: handshake OK\n");
+          if(fd_data->on_handshake)
+            fd_data->on_handshake(fd_data->arg, fd_data->tcp, fd_data->ssl);
+          fd_data = tcp_ssl_get(tcp);
+          if(NULL == fd_data)
+            return SSL_CLOSE_NOTIFY;
+        } else if(handshake != SSL_NOT_OK){
+          TCP_SSL_DEBUG("tcp_ssl_read: handshake error: %d\n", handshake);
+          if(fd_data->on_error)
+            fd_data->on_error(fd_data->arg, fd_data->tcp, handshake);
+          return handshake;
+          // With current code APP gets called twice at onError handler.
+          // Once here and again after return when handshake != SSL_CLOSE_NOTIFY.
+          // As always APP must never free resources at onError only at onDisconnect.
+        }
+      }
+    }
+  } while (p->tot_len - fd_data->pbuf_offset > 0);
+
+  tcp_recved(tcp, p->tot_len);
+  fd_data->tcp_pbuf = NULL;
+  pbuf_free(p);
+
+  return total_bytes;
+}
+
+SSL * tcp_ssl_get_ssl(struct tcp_pcb *tcp){
+  tcp_ssl_t * tcp_ssl = tcp_ssl_get(tcp);
+  if(tcp_ssl){
+    return tcp_ssl->ssl;
+  }
+  return NULL;
+}
+
+bool tcp_ssl_has(struct tcp_pcb *tcp){
+  return tcp_ssl_get(tcp) != NULL;
+}
+
+int tcp_ssl_is_server(struct tcp_pcb *tcp){
+  tcp_ssl_t * tcp_ssl = tcp_ssl_get(tcp);
+  if(tcp_ssl){
+    return tcp_ssl->type;
+  }
+  return -1;
+}
+
+void tcp_ssl_arg(struct tcp_pcb *tcp, void * arg){
+  tcp_ssl_t * item = tcp_ssl_get(tcp);
+  if(item) {
+    item->arg = arg;
+  }
+}
+
+void tcp_ssl_data(struct tcp_pcb *tcp, tcp_ssl_data_cb_t arg){
+  tcp_ssl_t * item = tcp_ssl_get(tcp);
+  if(item) {
+    item->on_data = arg;
+  }
+}
+
+void tcp_ssl_handshake(struct tcp_pcb *tcp, tcp_ssl_handshake_cb_t arg){
+  tcp_ssl_t * item = tcp_ssl_get(tcp);
+  if(item) {
+    item->on_handshake = arg;
+  }
+}
+
+void tcp_ssl_err(struct tcp_pcb *tcp, tcp_ssl_error_cb_t arg){
+  tcp_ssl_t * item = tcp_ssl_get(tcp);
+  if(item) {
+    item->on_error = arg;
+  }
+}
+
+static tcp_ssl_file_cb_t _tcp_ssl_file_cb = NULL;
+static void * _tcp_ssl_file_arg = NULL;
+
+void tcp_ssl_file(tcp_ssl_file_cb_t cb, void * arg){
+  _tcp_ssl_file_cb = cb;
+  _tcp_ssl_file_arg = arg;
+}
+
+int ax_get_file(const char *filename, uint8_t **buf) {
+    //TCP_SSL_DEBUG("ax_get_file: %s\n", filename);
+    if(_tcp_ssl_file_cb){
+      return _tcp_ssl_file_cb(_tcp_ssl_file_arg, filename, buf);
+    }
+    *buf = 0;
+    return 0;
+}
+
+tcp_ssl_t* tcp_ssl_get_by_fd(int fd) {
+  tcp_ssl_t * item = tcp_ssl_array;
+  while(item && item->fd != fd){
+    item = item->next;
+  }
+  return item;
+}
+/*
+ * The LWIP tcp raw version of the SOCKET_WRITE(A, B, C)
+ */
+int ax_port_write(int fd, uint8_t *data, uint16_t len) {
+  tcp_ssl_t *fd_data = NULL;
+  int tcp_len = 0;
+  err_t err = ERR_OK;
+
+  //TCP_SSL_DEBUG("ax_port_write: %d, %d\n", fd, len);
+
+  fd_data = tcp_ssl_get_by_fd(fd);
+  if(fd_data == NULL) {
+    //TCP_SSL_DEBUG("ax_port_write: tcp_ssl[%d] is NULL\n", fd);
+    return ERR_MEM;
+  }
+
+  if (data == NULL || len == 0) {
+    return 0;
+  }
+
+  if (tcp_sndbuf(fd_data->tcp) < len) {
+    tcp_len = tcp_sndbuf(fd_data->tcp);
+    if(tcp_len == 0) {
+      TCP_SSL_DEBUG("ax_port_write: tcp_sndbuf is zero: %d\n", len);
+      return ERR_MEM;
+    }
+  } else {
+    tcp_len = len;
+  }
+
+  if (tcp_len > 2 * fd_data->tcp->mss) {
+    tcp_len = 2 * fd_data->tcp->mss;
+  }
+
+  err = tcp_write(fd_data->tcp, data, tcp_len, TCP_WRITE_FLAG_COPY);
+  if(err < ERR_OK) {
+    if (err == ERR_MEM) {
+      TCP_SSL_DEBUG("ax_port_write: No memory %d (%d)\n", tcp_len, len);
+      return err;
+    }
+    TCP_SSL_DEBUG("ax_port_write: tcp_write error: %ld\n", err);
+    return err;
+  } else if (err == ERR_OK) {
+    //TCP_SSL_DEBUG("ax_port_write: tcp_output: %d / %d\n", tcp_len, len);
+    err = tcp_output(fd_data->tcp);
+    if(err != ERR_OK) {
+      TCP_SSL_DEBUG("ax_port_write: tcp_output err: %ld\n", err);
+      return err;
+    }
+  }
+
+  fd_data->last_wr += tcp_len;
+
+  return tcp_len;
+}
+
+/*
+ * The LWIP tcp raw version of the SOCKET_READ(A, B, C)
+ */
+int ax_port_read(int fd, uint8_t *data, int len) {
+  tcp_ssl_t *fd_data = NULL;
+  uint8_t *read_buf = NULL;
+  uint8_t *pread_buf = NULL;
+  u16_t recv_len = 0;
+
+  //TCP_SSL_DEBUG("ax_port_read: %d, %d\n", fd, len);
+
+  fd_data = tcp_ssl_get_by_fd(fd);
+  if (fd_data == NULL) {
+    TCP_SSL_DEBUG("ax_port_read: tcp_ssl[%d] is NULL\n", fd);
+    return ERR_TCP_SSL_INVALID_CLIENTFD_DATA;
+  }
+
+  if(fd_data->tcp_pbuf == NULL || fd_data->tcp_pbuf->tot_len == 0) {
+    return 0;
+  }
+
+  read_buf =(uint8_t*)calloc(fd_data->tcp_pbuf->len + 1, sizeof(uint8_t));
+  pread_buf = read_buf;
+  if (pread_buf != NULL){
+    recv_len = pbuf_copy_partial(fd_data->tcp_pbuf, read_buf, len, fd_data->pbuf_offset);
+    fd_data->pbuf_offset += recv_len;
+  }
+
+  if (recv_len != 0) {
+    memcpy(data, read_buf, recv_len);
+  }
+
+  if(len < recv_len) {
+    TCP_SSL_DEBUG("ax_port_read: got %d bytes more than expected\n", recv_len - len);
+  }
+
+  free(pread_buf);
+  pread_buf = NULL;
+
+  return recv_len;
+}
+
+void ax_wdt_feed() {}
+
+#endif

lib/ESPAsyncTCP-esphome/src/tcp_axtls.h

@@ -0,0 +1,98 @@
+/*
+  Asynchronous TCP library for Espressif MCUs
+
+  Copyright (c) 2016 Hristo Gochkov. All rights reserved.
+  This file is part of the esp8266 core for Arduino environment.
+
+  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
+*/
+/*
+ * Compatibility for AxTLS with LWIP raw tcp mode (http://lwip.wikia.com/wiki/Raw/TCP)
+ * Original Code and Inspiration: Slavey Karadzhov
+ */
+
+#ifndef LWIPR_COMPAT_H
+#define LWIPR_COMPAT_H
+
+#include <async_config.h>
+
+#if ASYNC_TCP_SSL_ENABLED
+
+#include "lwipopts.h"
+/*
+ * All those functions will run only if LWIP tcp raw mode is used
+ */
+#if LWIP_RAW==1
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <stdbool.h>
+#include "include/ssl.h"
+
+#define ERR_TCP_SSL_INVALID_SSL           -101
+#define ERR_TCP_SSL_INVALID_TCP           -102
+#define ERR_TCP_SSL_INVALID_CLIENTFD      -103
+#define ERR_TCP_SSL_INVALID_CLIENTFD_DATA -104
+#define ERR_TCP_SSL_INVALID_DATA          -105
+
+#define TCP_SSL_TYPE_CLIENT 0
+#define TCP_SSL_TYPE_SERVER 1
+
+#define tcp_ssl_ssl_write(A, B, C) tcp_ssl_write(A, B, C)
+#define tcp_ssl_ssl_read(A, B) tcp_ssl_read(A, B)
+
+typedef void (* tcp_ssl_data_cb_t)(void *arg, struct tcp_pcb *tcp, uint8_t * data, size_t len);
+typedef void (* tcp_ssl_handshake_cb_t)(void *arg, struct tcp_pcb *tcp, SSL *ssl);
+typedef void (* tcp_ssl_error_cb_t)(void *arg, struct tcp_pcb *tcp, int8_t error);
+typedef int (* tcp_ssl_file_cb_t)(void *arg, const char *filename, uint8_t **buf);
+
+uint8_t tcp_ssl_has_client();
+
+int tcp_ssl_new_client(struct tcp_pcb *tcp);
+
+SSL_CTX * tcp_ssl_new_server_ctx(const char *cert, const char *private_key_file, const char *password);
+int tcp_ssl_new_server(struct tcp_pcb *tcp, SSL_CTX* ssl_ctx);
+int tcp_ssl_is_server(struct tcp_pcb *tcp);
+
+int tcp_ssl_free(struct tcp_pcb *tcp);
+int tcp_ssl_read(struct tcp_pcb *tcp, struct pbuf *p);
+
+#ifdef AXTLS_2_0_0_SNDBUF
+int tcp_ssl_sndbuf(struct tcp_pcb *tcp);
+#endif
+
+int tcp_ssl_write(struct tcp_pcb *tcp, uint8_t *data, size_t len);
+
+void tcp_ssl_file(tcp_ssl_file_cb_t cb, void * arg);
+
+void tcp_ssl_arg(struct tcp_pcb *tcp, void * arg);
+void tcp_ssl_data(struct tcp_pcb *tcp, tcp_ssl_data_cb_t arg);
+void tcp_ssl_handshake(struct tcp_pcb *tcp, tcp_ssl_handshake_cb_t arg);
+void tcp_ssl_err(struct tcp_pcb *tcp, tcp_ssl_error_cb_t arg);
+
+SSL * tcp_ssl_get_ssl(struct tcp_pcb *tcp);
+bool tcp_ssl_has(struct tcp_pcb *tcp);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* LWIP_RAW==1 */
+
+#endif /* ASYNC_TCP_SSL_ENABLED */
+
+#endif /* LWIPR_COMPAT_H */

lib/ESPAsyncTCP-esphome/ssl/gen_server_cert.sh

@@ -0,0 +1,36 @@
+#!/bin/bash
+
+cat > ca_cert.conf << EOF  
+[ req ]
+distinguished_name     = req_distinguished_name
+prompt                 = no
+
+[ req_distinguished_name ]
+ O                      = Espressif Systems
+EOF
+
+openssl genrsa -out axTLS.ca_key.pem 2048
+openssl req -new -config ./ca_cert.conf -key axTLS.ca_key.pem -out axTLS.ca_x509.req
+openssl x509 -req -sha1 -days 5000 -signkey axTLS.ca_key.pem -CAkey axTLS.ca_key.pem -in axTLS.ca_x509.req -out axTLS.ca_x509.pem
+
+cat > certs.conf << EOF  
+[ req ]
+distinguished_name     = req_distinguished_name
+prompt                 = no
+
+[ req_distinguished_name ]
+ O                      = axTLS on ESP8266
+ CN                     = esp8266.local
+EOF
+
+openssl genrsa -out axTLS.key_1024.pem 1024
+openssl req -new -config ./certs.conf -key axTLS.key_1024.pem -out axTLS.x509_1024.req
+openssl x509 -req -sha1 -CAcreateserial -days 5000 -CA axTLS.ca_x509.pem -CAkey axTLS.ca_key.pem -in axTLS.x509_1024.req -out axTLS.x509_1024.pem
+
+openssl rsa -outform DER -in axTLS.key_1024.pem -out axTLS.key_1024
+openssl x509 -outform DER -in axTLS.x509_1024.pem -out axTLS.x509_1024.cer
+
+cat axTLS.key_1024 > server.key
+cat axTLS.x509_1024.cer > server.cer
+
+rm axTLS.* ca_cert.conf certs.conf

lib/NetworkClientSecure/README.md

@@ -0,0 +1,133 @@
+NetworkClientSecure
+================
+
+The NetworkClientSecure class implements support for secure connections using TLS (SSL).
+It inherits from NetworkClient and thus implements a superset of that class' interface.
+There are three ways to establish a secure connection using the NetworkClientSecure class:
+using a root certificate authority (CA) cert, using a root CA cert plus a client cert and key,
+and using a pre-shared key (PSK).
+
+Using a root certificate authority cert
+---------------------------------------
+This method authenticates the server and negotiates an encrypted connection.
+It is the same functionality as implemented in your web browser when you connect to HTTPS sites.
+
+If you are accessing your own server:
+- Generate a root certificate for your own certificate authority
+- Generate a cert & private key using your root certificate ("self-signed cert") for your server
+
+If you are accessing a public server:
+- Obtain the cert of the public CA that signed that server's cert
+Then:
+- In NetworkClientSecure use setCACert (or the appropriate connect method) to set the root cert of your
+  CA or of the public CA
+- When NetworkClientSecure connects to the target server it uses the CA cert to verify the certificate
+  presented by the server, and then negotiates encryption for the connection
+
+Please see the NetworkClientSecure example.
+
+Using a bundle of root certificate authority certificates
+---------------------------------------------------------
+This method is similar to the single root certificate verification above, but it uses a standard set of
+root certificates from Mozilla to authenticate against, while the previous method only accepts a single
+certificate for a given server. This allows the client to connect to all public SSL servers.
+
+To use this feature in PlatformIO:
+1. create a certificate bundle as described in the document below, or obtain a pre-built one you trust:
+https://docs.espressif.com/projects/esp-idf/en/latest/esp32/api-reference/protocols/esp_crt_bundle.html
+(gen_crt_bundle.py can be found in the /tools folder)
+   a. note: the full bundle will take up around 64k of flash space, but has minimal RAM usage, as only
+      the index of the certificates is kept in RAM
+2. Place the bundle under the file name "data/cert/x509_crt_bundle.bin" in your platformio project
+3. add "board_build.embed_files = data/cert/x509_crt_bundle.bin" in your platformio.ini
+4. add the following global declaration in your project:
+   extern const uint8_t rootca_crt_bundle_start[] asm("_binary_data_cert_x509_crt_bundle_bin_start");
+5. before initiating the first SSL connection, call
+   my_client.setCACertBundle(rootca_crt_bundle_start);
+
+To use this feature in Arduino IDE:
+If the Arduino IDE added support for embedding files in the meantime, then follow the instructions above.
+If not, you have three choices:
+1. convert your project to PlatformIO
+2. create a makefile where you can add the idf_component_register() declaration to include the certificate bundle
+3. Store the bundle as a SPIFFS file, but then you have to load it into RAM in runtime and waste 64k of precious memory
+
+Using a root CA cert and client cert/keys
+-----------------------------------------
+This method authenticates the server and additionally also authenticates
+the client to the server, then negotiates an encrypted connection.
+
+- Follow steps above
+- Using your root CA generate cert/key for your client
+- Register the keys with the server you will be accessing so the server can authenticate your client
+- In NetworkClientSecure use setCACert (or the appropriate connect method) to set the root cert of your
+  CA or of the public CA, this is used to authenticate the server
+- In NetworkClientSecure use setCertificate, and setPrivateKey (or the appropriate connect method) to
+  set your client's cert & key, this will be used to authenticate your client to the server
+- When NetworkClientSecure connects to the target server it uses the CA cert to verify the certificate
+  presented by the server, it will use the cert/key to authenticate your client to the server, and
+  it will then negotiate encryption for the connection
+
+Using Pre-Shared Keys (PSK)
+---------------------------
+
+TLS supports authentication and encryption using a pre-shared key (i.e. a key that both client and
+server know) as an alternative to the public key cryptography commonly used on the web for HTTPS.
+PSK is starting to be used for MQTT, e.g. in mosquitto, to simplify the set-up and avoid having to
+go through the whole CA, cert, and private key process.
+
+A pre-shared key is a binary string of up to 32 bytes and is commonly represented in hex form. In
+addition to the key, clients can also present an id and typically the server allows a different key
+to be associated with each client id. In effect this is very similar to username and password pairs,
+except that unlike a password the key is not directly transmitted to the server, thus a connection to a
+malicious server does not divulge the password. Plus the server is also authenticated to the client.
+
+To use PSK:
+- Generate a random hex string (generating an MD5 or SHA for some file is one way to do this)
+- Come up with a string id for your client and configure your server to accept the id/key pair
+- In NetworkClientSecure use setPreSharedKey (or the appropriate connect method) to
+  set the id/key combo
+- When NetworkClientSecure connects to the target server it uses the id/key combo to authenticate the
+  server (it must prove that it has the key too), authenticate the client and then negotiate
+  encryption for the connection
+
+Please see the NetworkClientPSK example.
+
+Specifying the ALPN Protocol
+----------------------------
+
+Application-Layer Protocol Negotiation (ALPN) is a Transport Layer Security (TLS) extension that allows
+the application layer to negotiate which protocol should be performed over a secure connection in a manner
+that avoids additional round trips and which is independent of the application-layer protocols.
+
+For example, this is used with AWS IoT Custom Authorizers where an MQTT client must set the ALPN protocol to ```mqtt```:
+
+```
+const char *aws_protos[] = {"mqtt", NULL};
+...
+wiFiClient.setAlpnProtocols(aws_protos);
+```
+
+Examples
+--------
+#### NetworkClientInsecure
+Demonstrates usage of insecure connection using `NetworkClientSecure::setInsecure()`
+#### NetworkClientPSK
+Wifi secure connection example for ESP32 using a pre-shared key (PSK)
+This is useful with MQTT servers instead of using a self-signed cert, tested with mosquitto.
+Running on TLS 1.2 using mbedTLS
+#### NetworkClientSecure
+Wifi secure connection example for ESP32
+Running on TLS 1.2 using mbedTLS
+#### NetworkClientSecureEnterprise
+This example demonstrates a secure connection to a WiFi network using WPA/WPA2 Enterprise (for example eduroam),
+and establishing a secure HTTPS connection with an external server (for example arduino.php5.sk) using the defined anonymous identity, user identity, and password.
+
+.. note::
+  This example is outdated and might not work. For more examples see [https://github.com/martinius96/ESP32-eduroam](https://github.com/martinius96/ESP32-eduroam)
+
+#### NetworkClientShowPeerCredentials
+Example of a establishing a secure connection and then showing the fingerprint of the certificate.
+This can be useful in an IoT setting to know for sure that you are connecting to the right server.
+Especially in situations where you cannot hardcode a trusted root certificate for long
+periods of time (as they tend to get replaced more often than the lifecycle of IoT hardware).

lib/NetworkClientSecure/examples/WiFiClientInsecure/WiFiClientInsecure.ino

@@ -0,0 +1,70 @@
+#include <NetworkClientSecure.h>
+#include <WiFi.h>
+
+/* This is a very INSECURE approach.
+ * If for some reason the secure, proper example NetworkClientSecure
+ * does not work for you; then you may want to check the
+ * NetworkClientTrustOnFirstUse example first. It is less secure than
+ * NetworkClientSecure, but a lot better than this totally insecure
+ * approach shown below.
+ */
+
+const char *ssid = "your-ssid";          // your network SSID (name of wifi network)
+const char *password = "your-password";  // your network password
+
+const char *server = "www.howsmyssl.com";  // Server URL
+
+NetworkClientSecure client;
+
+void setup() {
+  //Initialize serial and wait for port to open:
+  Serial.begin(115200);
+  delay(100);
+
+  Serial.print("Attempting to connect to SSID: ");
+  Serial.println(ssid);
+  WiFi.begin(ssid, password);
+
+  // attempt to connect to Wifi network:
+  while (WiFi.status() != WL_CONNECTED) {
+    Serial.print(".");
+    // wait 1 second for re-trying
+    delay(1000);
+  }
+
+  Serial.print("Connected to ");
+  Serial.println(ssid);
+
+  Serial.println("\nStarting connection to server...");
+  client.setInsecure();  //skip verification
+  if (!client.connect(server, 443)) {
+    Serial.println("Connection failed!");
+  } else {
+    Serial.println("Connected to server!");
+    // Make a HTTP request:
+    client.println("GET https://www.howsmyssl.com/a/check HTTP/1.0");
+    client.println("Host: www.howsmyssl.com");
+    client.println("Connection: close");
+    client.println();
+
+    while (client.connected()) {
+      String line = client.readStringUntil('\n');
+      if (line == "\r") {
+        Serial.println("headers received");
+        break;
+      }
+    }
+    // if there are incoming bytes available
+    // from the server, read them and print them:
+    while (client.available()) {
+      char c = client.read();
+      Serial.write(c);
+    }
+
+    client.stop();
+  }
+}
+
+void loop() {
+  // do nothing
+}

lib/NetworkClientSecure/examples/WiFiClientInsecure/ci.json

@@ -0,0 +1,5 @@
+{
+  "targets": {
+    "esp32h2": false
+  }
+}

lib/NetworkClientSecure/examples/WiFiClientPSK/WiFiClientPSK.ino

@@ -0,0 +1,86 @@
+/*
+  Wifi secure connection example for ESP32 using a pre-shared key (PSK)
+  This is useful with MQTT servers instead of using a self-signed cert, tested with mosquitto.
+  Running on TLS 1.2 using mbedTLS
+
+  To test run a test server using: openssl s_server -accept 8443 -psk 1a2b3c4d -nocert
+  It will show the http request made, but there's no easy way to send a reply back...
+
+  2017 - Evandro Copercini - Apache 2.0 License.
+  2018 - Adapted for PSK by Thorsten von Eicken
+*/
+
+#include <NetworkClientSecure.h>
+#include <WiFi.h>
+
+#if 0
+const char* ssid     = "your-ssid";     // your network SSID (name of wifi network)
+const char* password = "your-password"; // your network password
+#else
+const char *ssid = "test";            // your network SSID (name of wifi network)
+const char *password = "securetest";  // your network password
+#endif
+
+//const char*  server = "server.local";  // Server hostname
+const IPAddress server = IPAddress(192, 168, 0, 14);  // Server IP address
+const int port = 8443;                                // server's port (8883 for MQTT)
+
+const char *pskIdent = "Client_identity";  // PSK identity (sometimes called key hint)
+const char *psKey = "1a2b3c4d";            // PSK Key (must be hex string without 0x)
+
+NetworkClientSecure client;
+
+void setup() {
+  //Initialize serial and wait for port to open:
+  Serial.begin(115200);
+  delay(100);
+
+  Serial.print("Attempting to connect to SSID: ");
+  Serial.println(ssid);
+  WiFi.begin(ssid, password);
+
+  // attempt to connect to Wifi network:
+  while (WiFi.status() != WL_CONNECTED) {
+    Serial.print(".");
+    // wait 1 second for re-trying
+    delay(1000);
+  }
+
+  Serial.print("Connected to ");
+  Serial.println(ssid);
+
+  client.setPreSharedKey(pskIdent, psKey);
+
+  Serial.println("\nStarting connection to server...");
+  if (!client.connect(server, port)) {
+    Serial.println("Connection failed!");
+  } else {
+    Serial.println("Connected to server!");
+    // Make a HTTP request:
+    client.println("GET /a/check HTTP/1.0");
+    client.print("Host: ");
+    client.println(server);
+    client.println("Connection: close");
+    client.println();
+
+    while (client.connected()) {
+      String line = client.readStringUntil('\n');
+      if (line == "\r") {
+        Serial.println("headers received");
+        break;
+      }
+    }
+    // if there are incoming bytes available
+    // from the server, read them and print them:
+    while (client.available()) {
+      char c = client.read();
+      Serial.write(c);
+    }
+
+    client.stop();
+  }
+}
+
+void loop() {
+  // do nothing
+}

lib/NetworkClientSecure/examples/WiFiClientPSK/ci.json

@@ -0,0 +1,5 @@
+{
+  "targets": {
+    "esp32h2": false
+  }
+}

lib/NetworkClientSecure/examples/WiFiClientSecure/WiFiClientSecure.ino

@@ -0,0 +1,102 @@
+/*
+  Wifi secure connection example for ESP32
+  Running on TLS 1.2 using mbedTLS
+  Supporting the following ciphersuites:
+  "TLS_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384","TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384","TLS_DHE_RSA_WITH_AES_256_GCM_SHA384","TLS_ECDHE_ECDSA_WITH_AES_256_CCM","TLS_DHE_RSA_WITH_AES_256_CCM","TLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA384","TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA384","TLS_DHE_RSA_WITH_AES_256_CBC_SHA256","TLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA","TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA","TLS_DHE_RSA_WITH_AES_256_CBC_SHA","TLS_ECDHE_ECDSA_WITH_AES_256_CCM_8","TLS_DHE_RSA_WITH_AES_256_CCM_8","TLS_ECDHE_ECDSA_WITH_CAMELLIA_256_GCM_SHA384","TLS_ECDHE_RSA_WITH_CAMELLIA_256_GCM_SHA384","TLS_DHE_RSA_WITH_CAMELLIA_256_GCM_SHA384","TLS_ECDHE_ECDSA_WITH_CAMELLIA_256_CBC_SHA384","TLS_ECDHE_RSA_WITH_CAMELLIA_256_CBC_SHA384","TLS_DHE_RSA_WITH_CAMELLIA_256_CBC_SHA256","TLS_DHE_RSA_WITH_CAMELLIA_256_CBC_SHA","TLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256","TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256","TLS_DHE_RSA_WITH_AES_128_GCM_SHA256","TLS_ECDHE_ECDSA_WITH_AES_128_CCM","TLS_DHE_RSA_WITH_AES_128_CCM","TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA256","TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA256","TLS_DHE_RSA_WITH_AES_128_CBC_SHA256","TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA","TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA","TLS_DHE_RSA_WITH_AES_128_CBC_SHA","TLS_ECDHE_ECDSA_WITH_AES_128_CCM_8","TLS_DHE_RSA_WITH_AES_128_CCM_8","TLS_ECDHE_ECDSA_WITH_CAMELLIA_128_GCM_SHA256","TLS_ECDHE_RSA_WITH_CAMELLIA_128_GCM_SHA256","TLS_DHE_RSA_WITH_CAMELLIA_128_GCM_SHA256","TLS_ECDHE_ECDSA_WITH_CAMELLIA_128_CBC_SHA256","TLS_ECDHE_RSA_WITH_CAMELLIA_128_CBC_SHA256","TLS_DHE_RSA_WITH_CAMELLIA_128_CBC_SHA256","TLS_DHE_RSA_WITH_CAMELLIA_128_CBC_SHA","TLS_ECDHE_ECDSA_WITH_3DES_EDE_CBC_SHA","TLS_ECDHE_RSA_WITH_3DES_EDE_CBC_SHA","TLS_DHE_RSA_WITH_3DES_EDE_CBC_SHA","TLS_DHE_PSK_WITH_AES_256_GCM_SHA384","TLS_DHE_PSK_WITH_AES_256_CCM","TLS_ECDHE_PSK_WITH_AES_256_CBC_SHA384","TLS_DHE_PSK_WITH_AES_256_CBC_SHA384","TLS_ECDHE_PSK_WITH_AES_256_CBC_SHA","TLS_DHE_PSK_WITH_AES_256_CBC_SHA","TLS_DHE_PSK_WITH_CAMELLIA_256_GCM_SHA384","TLS_ECDHE_PSK_WITH_CAMELLIA_256_CBC_SHA384","TLS_DHE_PSK_WITH_CAMELLIA_256_CBC_SHA384","TLS_PSK_DHE_WITH_AES_256_CCM_8","TLS_DHE_PSK_WITH_AES_128_GCM_SHA256","TLS_DHE_PSK_WITH_AES_128_CCM","TLS_ECDHE_PSK_WITH_AES_128_CBC_SHA256","TLS_DHE_PSK_WITH_AES_128_CBC_SHA256","TLS_ECDHE_PSK_WITH_AES_128_CBC_SHA","TLS_DHE_PSK_WITH_AES_128_CBC_SHA","TLS_DHE_PSK_WITH_CAMELLIA_128_GCM_SHA256","TLS_DHE_PSK_WITH_CAMELLIA_128_CBC_SHA256","TLS_ECDHE_PSK_WITH_CAMELLIA_128_CBC_SHA256","TLS_PSK_DHE_WITH_AES_128_CCM_8","TLS_ECDHE_PSK_WITH_3DES_EDE_CBC_SHA","TLS_DHE_PSK_WITH_3DES_EDE_CBC_SHA","TLS_RSA_WITH_AES_256_GCM_SHA384","TLS_RSA_WITH_AES_256_CCM","TLS_RSA_WITH_AES_256_CBC_SHA256","TLS_RSA_WITH_AES_256_CBC_SHA","TLS_ECDH_RSA_WITH_AES_256_GCM_SHA384","TLS_ECDH_RSA_WITH_AES_256_CBC_SHA384","TLS_ECDH_RSA_WITH_AES_256_CBC_SHA","TLS_ECDH_ECDSA_WITH_AES_256_GCM_SHA384","TLS_ECDH_ECDSA_WITH_AES_256_CBC_SHA384","TLS_ECDH_ECDSA_WITH_AES_256_CBC_SHA","TLS_RSA_WITH_AES_256_CCM_8","TLS_RSA_WITH_CAMELLIA_256_GCM_SHA384","TLS_RSA_WITH_CAMELLIA_256_CBC_SHA256","TLS_RSA_WITH_CAMELLIA_256_CBC_SHA","TLS_ECDH_RSA_WITH_CAMELLIA_256_GCM_SHA384","TLS_ECDH_RSA_WITH_CAMELLIA_256_CBC_SHA384","TLS_ECDH_ECDSA_WITH_CAMELLIA_256_GCM_SHA384","TLS_ECDH_ECDSA_WITH_CAMELLIA_256_CBC_SHA384","TLS_RSA_WITH_AES_128_GCM_SHA256","TLS_RSA_WITH_AES_128_CCM","TLS_RSA_WITH_AES_128_CBC_SHA256","TLS_RSA_WITH_AES_128_CBC_SHA","TLS_ECDH_RSA_WITH_AES_128_GCM_SHA256","TLS_ECDH_RSA_WITH_AES_128_CBC_SHA256","TLS_ECDH_RSA_WITH_AES_128_CBC_SHA","TLS_ECDH_ECDSA_WITH_AES_128_GCM_SHA256","TLS_ECDH_ECDSA_WITH_AES_128_CBC_SHA256","TLS_ECDH_ECDSA_WITH_AES_128_CBC_SHA","TLS_RSA_WITH_AES_128_CCM_8","TLS_RSA_WITH_CAMELLIA_128_GCM_SHA256","TLS_RSA_WITH_CAMELLIA_128_CBC_SHA256","TLS_RSA_WITH_CAMELLIA_128_CBC_SHA","TLS_ECDH_RSA_WITH_CAMELLIA_128_GCM_SHA256","TLS_ECDH_RSA_WITH_CAMELLIA_128_CBC_SHA256","TLS_ECDH_ECDSA_WITH_CAMELLIA_128_GCM_SHA256","TLS_ECDH_ECDSA_WITH_CAMELLIA_128_CBC_SHA256","TLS_RSA_WITH_3DES_EDE_CBC_SHA","TLS_ECDH_RSA_WITH_3DES_EDE_CBC_SHA","TLS_ECDH_ECDSA_WITH_3DES_EDE_CBC_SHA","TLS_RSA_PSK_WITH_AES_256_GCM_SHA384","TLS_RSA_PSK_WITH_AES_256_CBC_SHA384","TLS_RSA_PSK_WITH_AES_256_CBC_SHA","TLS_RSA_PSK_WITH_CAMELLIA_256_GCM_SHA384","TLS_RSA_PSK_WITH_CAMELLIA_256_CBC_SHA384","TLS_RSA_PSK_WITH_AES_128_GCM_SHA256","TLS_RSA_PSK_WITH_AES_128_CBC_SHA256","TLS_RSA_PSK_WITH_AES_128_CBC_SHA","TLS_RSA_PSK_WITH_CAMELLIA_128_GCM_SHA256","TLS_RSA_PSK_WITH_CAMELLIA_128_CBC_SHA256","TLS_RSA_PSK_WITH_3DES_EDE_CBC_SHA","TLS_PSK_WITH_AES_256_GCM_SHA384","TLS_PSK_WITH_AES_256_CCM","TLS_PSK_WITH_AES_256_CBC_SHA384","TLS_PSK_WITH_AES_256_CBC_SHA","TLS_PSK_WITH_CAMELLIA_256_GCM_SHA384","TLS_PSK_WITH_CAMELLIA_256_CBC_SHA384","TLS_PSK_WITH_AES_256_CCM_8","TLS_PSK_WITH_AES_128_GCM_SHA256","TLS_PSK_WITH_AES_128_CCM","TLS_PSK_WITH_AES_128_CBC_SHA256","TLS_PSK_WITH_AES_128_CBC_SHA","TLS_PSK_WITH_CAMELLIA_128_GCM_SHA256","TLS_PSK_WITH_CAMELLIA_128_CBC_SHA256","TLS_PSK_WITH_AES_128_CCM_8","TLS_PSK_WITH_3DES_EDE_CBC_SHA","TLS_EMPTY_RENEGOTIATION_INFO_SCSV"]
+  2017 - Evandro Copercini - Apache 2.0 License.
+*/
+
+#include <NetworkClientSecure.h>
+#include <WiFi.h>
+
+const char *ssid = "your-ssid";          // your network SSID (name of wifi network)
+const char *password = "your-password";  // your network password
+
+const char *server = "www.howsmyssl.com";  // Server URL
+
+// www.howsmyssl.com root certificate authority, to verify the server
+// change it to your server root CA
+// SHA1 fingerprint is broken now!
+
+const char *test_root_ca = "-----BEGIN CERTIFICATE-----\n"
+                           "MIIDSjCCAjKgAwIBAgIQRK+wgNajJ7qJMDmGLvhAazANBgkqhkiG9w0BAQUFADA/\n"
+                           "MSQwIgYDVQQKExtEaWdpdGFsIFNpZ25hdHVyZSBUcnVzdCBDby4xFzAVBgNVBAMT\n"
+                           "DkRTVCBSb290IENBIFgzMB4XDTAwMDkzMDIxMTIxOVoXDTIxMDkzMDE0MDExNVow\n"
+                           "PzEkMCIGA1UEChMbRGlnaXRhbCBTaWduYXR1cmUgVHJ1c3QgQ28uMRcwFQYDVQQD\n"
+                           "Ew5EU1QgUm9vdCBDQSBYMzCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEB\n"
+                           "AN+v6ZdQCINXtMxiZfaQguzH0yxrMMpb7NnDfcdAwRgUi+DoM3ZJKuM/IUmTrE4O\n"
+                           "rz5Iy2Xu/NMhD2XSKtkyj4zl93ewEnu1lcCJo6m67XMuegwGMoOifooUMM0RoOEq\n"
+                           "OLl5CjH9UL2AZd+3UWODyOKIYepLYYHsUmu5ouJLGiifSKOeDNoJjj4XLh7dIN9b\n"
+                           "xiqKqy69cK3FCxolkHRyxXtqqzTWMIn/5WgTe1QLyNau7Fqckh49ZLOMxt+/yUFw\n"
+                           "7BZy1SbsOFU5Q9D8/RhcQPGX69Wam40dutolucbY38EVAjqr2m7xPi71XAicPNaD\n"
+                           "aeQQmxkqtilX4+U9m5/wAl0CAwEAAaNCMEAwDwYDVR0TAQH/BAUwAwEB/zAOBgNV\n"
+                           "HQ8BAf8EBAMCAQYwHQYDVR0OBBYEFMSnsaR7LHH62+FLkHX/xBVghYkQMA0GCSqG\n"
+                           "SIb3DQEBBQUAA4IBAQCjGiybFwBcqR7uKGY3Or+Dxz9LwwmglSBd49lZRNI+DT69\n"
+                           "ikugdB/OEIKcdBodfpga3csTS7MgROSR6cz8faXbauX+5v3gTt23ADq1cEmv8uXr\n"
+                           "AvHRAosZy5Q6XkjEGB5YGV8eAlrwDPGxrancWYaLbumR9YbK+rlmM6pZW87ipxZz\n"
+                           "R8srzJmwN0jP41ZL9c8PDHIyh8bwRLtTcm1D9SZImlJnt1ir/md2cXjbDaJWFBM5\n"
+                           "JDGFoqgCWjBH4d1QB7wCCZAA62RjYJsWvIjJEubSfZGL+T0yjWW06XyxV3bqxbYo\n"
+                           "Ob8VZRzI9neWagqNdwvYkQsEjgfbKbYK7p2CNTUQ\n"
+                           "-----END CERTIFICATE-----\n";
+
+// You can use x.509 client certificates if you want
+//const char* test_client_key = "";   //to verify the client
+//const char* test_client_cert = "";  //to verify the client
+
+NetworkClientSecure client;
+
+void setup() {
+  //Initialize serial and wait for port to open:
+  Serial.begin(115200);
+  delay(100);
+
+  Serial.print("Attempting to connect to SSID: ");
+  Serial.println(ssid);
+  WiFi.begin(ssid, password);
+
+  // attempt to connect to Wifi network:
+  while (WiFi.status() != WL_CONNECTED) {
+    Serial.print(".");
+    // wait 1 second for re-trying
+    delay(1000);
+  }
+
+  Serial.print("Connected to ");
+  Serial.println(ssid);
+
+  client.setCACert(test_root_ca);
+  //client.setCertificate(test_client_cert); // for client verification
+  //client.setPrivateKey(test_client_key);	// for client verification
+
+  Serial.println("\nStarting connection to server...");
+  if (!client.connect(server, 443)) {
+    Serial.println("Connection failed!");
+  } else {
+    Serial.println("Connected to server!");
+    // Make a HTTP request:
+    client.println("GET https://www.howsmyssl.com/a/check HTTP/1.0");
+    client.println("Host: www.howsmyssl.com");
+    client.println("Connection: close");
+    client.println();
+
+    while (client.connected()) {
+      String line = client.readStringUntil('\n');
+      if (line == "\r") {
+        Serial.println("headers received");
+        break;
+      }
+    }
+    // if there are incoming bytes available
+    // from the server, read them and print them:
+    while (client.available()) {
+      char c = client.read();
+      Serial.write(c);
+    }
+
+    client.stop();
+  }
+}
+
+void loop() {
+  // do nothing
+}

lib/NetworkClientSecure/examples/WiFiClientSecure/ci.json

@@ -0,0 +1,5 @@
+{
+  "targets": {
+    "esp32h2": false
+  }
+}

lib/NetworkClientSecure/examples/WiFiClientSecureEnterprise/WiFiClientSecureEnterprise.ino

@@ -0,0 +1,132 @@
+/*|-----------------------------------------------------------|*/
+/*|WORKING EXAMPLE FOR HTTPS CONNECTION                       |*/
+/*|Author: Bc. Martin Chlebovec                               |*/
+/*|Technical University of Košice                             |*/
+/*|TESTED BOARDS: Devkit v1 DOIT, Devkitc v4                  |*/
+/*|CORE: 0.9x, 1.0.0, 1.0.1 tested, working (newer not tested)|*/
+/*|Supported methods: PEAP + MsCHAPv2, EAP-TTLS + MsCHAPv2    |*/
+/*|-----------------------------------------------------------|*/
+
+// This example demonstrates a secure connection to a WiFi network using WPA/WPA2 Enterprise (for example eduroam),
+// and establishing a secure HTTPS connection with an external server (for example arduino.php5.sk) using the defined anonymous identity, user identity, and password.
+
+// Note: this example is outdated and may not work!
+// For more examples see https://github.com/martinius96/ESP32-eduroam
+
+#include <WiFi.h>
+#include <NetworkClientSecure.h>
+#if __has_include("esp_eap_client.h")
+#include "esp_eap_client.h"
+#else
+#include "esp_wpa2.h"
+#endif
+#include <Wire.h>
+#define EAP_ANONYMOUS_IDENTITY "anonymous@example.com"  //anonymous identity
+#define EAP_IDENTITY           "id@example.com"         //user identity
+#define EAP_PASSWORD           "password"               //eduroam user password
+const char *ssid = "eduroam";                           // eduroam SSID
+const char *host = "arduino.php5.sk";                   //external server domain for HTTPS connection
+int counter = 0;
+const char *test_root_ca = "-----BEGIN CERTIFICATE-----\n"
+                           "MIIEsTCCA5mgAwIBAgIQCKWiRs1LXIyD1wK0u6tTSTANBgkqhkiG9w0BAQsFADBh\n"
+                           "MQswCQYDVQQGEwJVUzEVMBMGA1UEChMMRGlnaUNlcnQgSW5jMRkwFwYDVQQLExB3\n"
+                           "d3cuZGlnaWNlcnQuY29tMSAwHgYDVQQDExdEaWdpQ2VydCBHbG9iYWwgUm9vdCBD\n"
+                           "QTAeFw0xNzExMDYxMjIzMzNaFw0yNzExMDYxMjIzMzNaMF4xCzAJBgNVBAYTAlVT\n"
+                           "MRUwEwYDVQQKEwxEaWdpQ2VydCBJbmMxGTAXBgNVBAsTEHd3dy5kaWdpY2VydC5j\n"
+                           "b20xHTAbBgNVBAMTFFJhcGlkU1NMIFJTQSBDQSAyMDE4MIIBIjANBgkqhkiG9w0B\n"
+                           "AQEFAAOCAQ8AMIIBCgKCAQEA5S2oihEo9nnpezoziDtx4WWLLCll/e0t1EYemE5n\n"
+                           "+MgP5viaHLy+VpHP+ndX5D18INIuuAV8wFq26KF5U0WNIZiQp6mLtIWjUeWDPA28\n"
+                           "OeyhTlj9TLk2beytbtFU6ypbpWUltmvY5V8ngspC7nFRNCjpfnDED2kRyJzO8yoK\n"
+                           "MFz4J4JE8N7NA1uJwUEFMUvHLs0scLoPZkKcewIRm1RV2AxmFQxJkdf7YN9Pckki\n"
+                           "f2Xgm3b48BZn0zf0qXsSeGu84ua9gwzjzI7tbTBjayTpT+/XpWuBVv6fvarI6bik\n"
+                           "KB859OSGQuw73XXgeuFwEPHTIRoUtkzu3/EQ+LtwznkkdQIDAQABo4IBZjCCAWIw\n"
+                           "HQYDVR0OBBYEFFPKF1n8a8ADIS8aruSqqByCVtp1MB8GA1UdIwQYMBaAFAPeUDVW\n"
+                           "0Uy7ZvCj4hsbw5eyPdFVMA4GA1UdDwEB/wQEAwIBhjAdBgNVHSUEFjAUBggrBgEF\n"
+                           "BQcDAQYIKwYBBQUHAwIwEgYDVR0TAQH/BAgwBgEB/wIBADA0BggrBgEFBQcBAQQo\n"
+                           "MCYwJAYIKwYBBQUHMAGGGGh0dHA6Ly9vY3NwLmRpZ2ljZXJ0LmNvbTBCBgNVHR8E\n"
+                           "OzA5MDegNaAzhjFodHRwOi8vY3JsMy5kaWdpY2VydC5jb20vRGlnaUNlcnRHbG9i\n"
+                           "YWxSb290Q0EuY3JsMGMGA1UdIARcMFowNwYJYIZIAYb9bAECMCowKAYIKwYBBQUH\n"
+                           "AgEWHGh0dHBzOi8vd3d3LmRpZ2ljZXJ0LmNvbS9DUFMwCwYJYIZIAYb9bAEBMAgG\n"
+                           "BmeBDAECATAIBgZngQwBAgIwDQYJKoZIhvcNAQELBQADggEBAH4jx/LKNW5ZklFc\n"
+                           "YWs8Ejbm0nyzKeZC2KOVYR7P8gevKyslWm4Xo4BSzKr235FsJ4aFt6yAiv1eY0tZ\n"
+                           "/ZN18bOGSGStoEc/JE4ocIzr8P5Mg11kRYHbmgYnr1Rxeki5mSeb39DGxTpJD4kG\n"
+                           "hs5lXNoo4conUiiJwKaqH7vh2baryd8pMISag83JUqyVGc2tWPpO0329/CWq2kry\n"
+                           "qv66OSMjwulUz0dXf4OHQasR7CNfIr+4KScc6ABlQ5RDF86PGeE6kdwSQkFiB/cQ\n"
+                           "ysNyq0jEDQTkfa2pjmuWtMCNbBnhFXBYejfubIhaUbEv2FOQB3dCav+FPg5eEveX\n"
+                           "TVyMnGo=\n"
+                           "-----END CERTIFICATE-----\n";
+// You can use x.509 client certificates if you want
+//const char* test_client_key = "";   //to verify the client
+//const char* test_client_cert = "";  //to verify the client
+NetworkClientSecure client;
+void setup() {
+  Serial.begin(115200);
+  delay(10);
+  Serial.println();
+  Serial.print("Connecting to network: ");
+  Serial.println(ssid);
+  WiFi.disconnect(true);  //disconnect form wifi to set new wifi connection
+  WiFi.mode(WIFI_STA);    //init wifi mode
+#if __has_include("esp_eap_client.h")
+  esp_eap_client_set_identity((uint8_t *)EAP_ANONYMOUS_IDENTITY, strlen(EAP_ANONYMOUS_IDENTITY));  //provide identity
+  esp_eap_client_set_username((uint8_t *)EAP_IDENTITY, strlen(EAP_IDENTITY));                      //provide username
+  esp_eap_client_set_password((uint8_t *)EAP_PASSWORD, strlen(EAP_PASSWORD));                      //provide password
+  esp_wifi_sta_enterprise_enable();
+#else
+  esp_wifi_sta_wpa2_ent_set_identity((uint8_t *)EAP_ANONYMOUS_IDENTITY, strlen(EAP_ANONYMOUS_IDENTITY));  //provide identity
+  esp_wifi_sta_wpa2_ent_set_username((uint8_t *)EAP_IDENTITY, strlen(EAP_IDENTITY));                      //provide username
+  esp_wifi_sta_wpa2_ent_set_password((uint8_t *)EAP_PASSWORD, strlen(EAP_PASSWORD));                      //provide password
+  esp_wifi_sta_wpa2_ent_enable();
+#endif
+  WiFi.begin(ssid);  //connect to wifi
+  while (WiFi.status() != WL_CONNECTED) {
+    delay(500);
+    Serial.print(".");
+    counter++;
+    if (counter >= 60) {  //after 30 seconds timeout - reset board (on unsuccessful connection)
+      ESP.restart();
+    }
+  }
+  client.setCACert(test_root_ca);
+  //client.setCertificate(test_client_cert); // for client verification - certificate
+  //client.setPrivateKey(test_client_key);  // for client verification - private key
+  Serial.println("");
+  Serial.println("WiFi connected");
+  Serial.println("IP address set: ");
+  Serial.println(WiFi.localIP());  //print LAN IP
+}
+void loop() {
+  if (WiFi.status() == WL_CONNECTED) {  //if we are connected to eduroam network
+    counter = 0;                        //reset counter
+    Serial.println("Wifi is still connected with IP: ");
+    Serial.println(WiFi.localIP());            //inform user about his IP address
+  } else if (WiFi.status() != WL_CONNECTED) {  //if we lost connection, retry
+    WiFi.begin(ssid);
+  }
+  while (WiFi.status() != WL_CONNECTED) {  //during lost connection, print dots
+    delay(500);
+    Serial.print(".");
+    counter++;
+    if (counter >= 60) {  //30 seconds timeout - reset board
+      ESP.restart();
+    }
+  }
+  Serial.print("Connecting to website: ");
+  Serial.println(host);
+  if (client.connect(host, 443)) {
+    String url = "/rele/rele1.txt";
+    client.print(String("GET ") + url + " HTTP/1.1\r\n" + "Host: " + host + "\r\n" + "User-Agent: ESP32\r\n" + "Connection: close\r\n\r\n");
+    while (client.connected()) {
+      String header = client.readStringUntil('\n');
+      Serial.println(header);
+      if (header == "\r") {
+        break;
+      }
+    }
+    String line = client.readStringUntil('\n');
+    Serial.println(line);
+  } else {
+    Serial.println("Connection unsuccessful");
+  }
+  delay(5000);
+}

lib/NetworkClientSecure/examples/WiFiClientSecureEnterprise/ci.json

@@ -0,0 +1,5 @@
+{
+  "targets": {
+    "esp32h2": false
+  }
+}

lib/NetworkClientSecure/examples/WiFiClientSecureProtocolUpgrade/WiFiClientSecureProtocolUpgrade.ino

@@ -0,0 +1,190 @@
+/* STARTSSL example
+
+   Inline upgrading from a clear-text connection to an SSL/TLS connection.
+
+   Some protocols such as SMTP, XMPP, Mysql, Postgresql and others allow, or require,
+   that you start the connection without encryption; and then send a command to switch
+   over to encryption.
+
+   E.g. a typical SMTP submission would entail a dialog such as this:
+
+   1. client connects to server in the clear
+   2. server says hello
+   3. client sents a EHLO
+   4. server tells the client that it supports SSL/TLS
+   5. client sends a 'STARTTLS' to make use of this faciltiy
+   6. client/server negiotiate a SSL or TLS connection.
+   7. client sends another EHLO
+   8. server now tells the client what (else) is supported; such as additional authentication options.
+   ... conversation continues encrypted.
+
+   This can be enabled in NetworkClientSecure by telling it to start in plaintext:
+
+          client.setPlainStart();
+
+   and client is than a plain, TCP, connection (just as NetworkClient would be); until the client calls
+   the method:
+
+          client.startTLS(); // returns zero on error; non zero on success.
+
+    After which things switch to TLS/SSL.
+*/
+
+#include <WiFi.h>
+#include <NetworkClientSecure.h>
+
+#ifndef WIFI_NETWORK
+#define WIFI_NETWORK "YOUR Wifi SSID"
+#endif
+
+#ifndef WIFI_PASSWD
+#define WIFI_PASSWD "your-secret-password"
+#endif
+
+#ifndef SMTP_HOST
+#define SMTP_HOST "smtp.gmail.com"
+#endif
+
+#ifndef SMTP_PORT
+#define SMTP_PORT (587)  // Standard (plaintext) submission port
+#endif
+
+const char *ssid = WIFI_NETWORK;        // your network SSID (name of wifi network)
+const char *password = WIFI_PASSWD;     // your network password
+const char *server = SMTP_HOST;         // Server URL
+const int submission_port = SMTP_PORT;  // submission port.
+
+NetworkClientSecure client;
+
+static bool readAllSMTPLines();
+
+void setup() {
+  int ret;
+  //Initialize serial and wait for port to open:
+  Serial.begin(115200);
+  delay(100);
+
+  Serial.print("Attempting to connect to SSID: ");
+  Serial.print(ssid);
+  WiFi.begin(ssid, password);
+
+  // attempt to connect to Wifi network:
+  while (WiFi.status() != WL_CONNECTED) {
+    Serial.print(".");
+    // wait 1 second for re-trying
+    delay(1000);
+  }
+
+  Serial.print("Connected to ");
+  Serial.println(ssid);
+
+  Serial.printf("\nStarting connection to server: %s:%d\n", server, submission_port);
+
+  // skip verification for this demo. In production one should at the very least
+  // enable TOFU; or ideally hardcode a (CA) certificate that is trusted.
+  client.setInsecure();
+
+  // Enable a plain-test start.
+  client.setPlainStart();
+
+  if (!client.connect(server, SMTP_PORT)) {
+    Serial.println("Connection failed!");
+    return;
+  };
+
+  Serial.println("Connected to server (in the clear, in plaintest)");
+
+  if (!readAllSMTPLines()) {
+    goto err;
+  }
+
+  Serial.println("Sending  : EHLO\t\tin the clear");
+  client.print("EHLO there\r\n");
+
+  if (!readAllSMTPLines()) {
+    goto err;
+  }
+
+  Serial.println("Sending  : STARTTLS\t\tin the clear");
+  client.print("STARTTLS\r\n");
+
+  if (!readAllSMTPLines()) {
+    goto err;
+  }
+
+  Serial.println("Upgrading connection to TLS");
+  if ((ret = client.startTLS()) <= 0) {
+    Serial.printf("Upgrade connection failed: err %d\n", ret);
+    goto err;
+  }
+
+  Serial.println("Sending  : EHLO again\t\tover the now encrypted connection");
+  client.print("EHLO again\r\n");
+
+  if (!readAllSMTPLines()) {
+    goto err;
+  }
+
+  // normally, as this point - we'd be authenticating and then be submitting
+  // an email. This has been left out of this example.
+
+  Serial.println("Sending  : QUIT\t\t\tover the now encrypted connection");
+  client.print("QUIT\r\n");
+
+  if (!readAllSMTPLines()) {
+    goto err;
+  }
+
+  Serial.println("Completed OK\n");
+err:
+  Serial.println("Closing connection");
+  client.stop();
+}
+
+// SMTP command repsponse start with three digits and a space;
+// or, for continuation, with three digits and a '-'.
+static bool readAllSMTPLines() {
+  String s = "";
+  int i;
+
+  // blocking read; we cannot rely on a timeout
+  // of a NetworkClientSecure read; as it is non
+  // blocking.
+  const unsigned long timeout = 15 * 1000;
+  unsigned long start = millis();  // the timeout is for the entire CMD block response; not per character/line.
+  while (1) {
+    while ((i = client.available()) == 0 && millis() - start < timeout) {
+      /* .. wait */
+    };
+    if (i == 0) {
+      Serial.println("Timeout reading SMTP response");
+      return false;
+    };
+    if (i < 0) {
+      break;
+    }
+
+    i = client.read();
+    if (i < 0) {
+      break;
+    }
+
+    if (i > 31 && i < 128) {
+      s += (char)i;
+    }
+    if (i == 0x0A) {
+      Serial.print("Receiving: ");
+      Serial.println(s);
+      if (s.charAt(3) == ' ') {
+        return true;
+      }
+      s = "";
+    }
+  }
+  Serial.printf("Error reading SMTP command response line: %d\n", i);
+  return false;
+}
+
+void loop() {
+  // do nothing
+}

lib/NetworkClientSecure/examples/WiFiClientSecureProtocolUpgrade/ci.json

@@ -0,0 +1,5 @@
+{
+  "targets": {
+    "esp32h2": false
+  }
+}

lib/NetworkClientSecure/examples/WiFiClientShowPeerCredentials/WiFiClientShowPeerCredentials.ino

@@ -0,0 +1,98 @@
+// NetworkClientShowPeerCredentials
+//
+// Example of a establishing a secure connection and then
+// showing the fingerprint of the certificate. This can
+// be useful in an IoT setting to know for sure that you
+// are connecting to the right server. Especially in
+// situations where you cannot hardcode a trusted root
+// certificate for long periods of time (as they tend to
+// get replaced more often than the lifecycle of IoT
+// hardware).
+//
+
+#include <WiFi.h>
+#include <HTTPClient.h>
+#include <NetworkClientSecure.h>
+
+#ifndef WIFI_NETWORK
+#define WIFI_NETWORK "MyWifiNetwork"
+#endif
+
+#ifndef WIFI_PASSWD
+#define WIFI_PASSWD "MySecretWifiPassword"
+#endif
+
+#define URL "https://arduino.cc"
+
+void demo() {
+  NetworkClientSecure *client = new NetworkClientSecure;
+  client->setInsecure();  //
+
+  HTTPClient https;
+  if (!https.begin(*client, URL)) {
+    Serial.println("HTTPS setup failed");
+    return;
+  };
+
+  https.setTimeout(5000);
+
+  int httpCode = https.GET();
+  if (httpCode != 200) {
+    Serial.print("Connect failed: ");
+    Serial.println(https.errorToString(httpCode));
+    return;
+  }
+
+  const mbedtls_x509_crt *peer = client->getPeerCertificate();
+
+  // Show general output / certificate information
+  //
+  char buf[1024];
+  int l = mbedtls_x509_crt_info(buf, sizeof(buf), "", peer);
+  if (l <= 0) {
+    Serial.println("Peer conversion to printable buffer failed");
+    return;
+  };
+  Serial.println();
+  Serial.println(buf);
+
+  uint8_t fingerprint_remote[32];
+  if (!client->getFingerprintSHA256(fingerprint_remote)) {
+    Serial.println("Failed to get the fingerprint");
+    return;
+  }
+  // Fingerprint late 2021
+  Serial.println("Expecting Fingerprint (SHA256): 70 CF A4 B7 5D 09 E9 2A 52 A8 B6 85 B5 0B D6 BE 83 47 83 5B 3A 4D 3C 3E 32 30 EC 1D 61 98 D7 0F");
+  Serial.print(" Received Fingerprint (SHA256): ");
+
+  for (int i = 0; i < 32; i++) {
+    Serial.print(fingerprint_remote[i], HEX);
+    Serial.print(" ");
+  };
+  Serial.println("");
+};
+
+void setup() {
+  Serial.begin(115200);
+  Serial.println("Started " __FILE__ " build " __DATE__ " " __TIME__);
+
+  WiFi.mode(WIFI_STA);
+  WiFi.begin(WIFI_NETWORK, WIFI_PASSWD);
+
+  while (WiFi.waitForConnectResult() != WL_CONNECTED) {
+    Serial.println("Wifi fail - rebooting");
+    delay(5000);
+    ESP.restart();
+  }
+}
+
+void loop() {
+  bool already_tried = false;
+  if ((millis() < 1000) || already_tried) {
+    return;
+  }
+  already_tried = true;
+
+  // Run the test just once.
+  demo();
+}

lib/NetworkClientSecure/examples/WiFiClientShowPeerCredentials/ci.json

@@ -0,0 +1,5 @@
+{
+  "targets": {
+    "esp32h2": false
+  }
+}

lib/NetworkClientSecure/examples/WiFiClientTrustOnFirstUse/WiFiClientTrustOnFirstUse.ino

@@ -0,0 +1,270 @@
+/* For any secure connection - it is (at least) essential for the
+   the client to verify that it is talking with the server it
+   thinks it is talking to. And not some (invisible) man in the middle.
+
+   See https://en.wikipedia.org/wiki/Man-in-the-middle_attack,
+   https://www.ai.rug.nl/mas/finishedprojects/2011/TLS/hermsencomputerservices.nl/mas/mitm.html or
+   https://medium.com/@munteanu210/ssl-certificates-vs-man-in-the-middle-attacks-3fb7846fa5db
+   for some background on this.
+
+   Unfortunately this means that one needs to hardcode a server
+   public key, certificate or some cryptographically strong hash
+   thereoff into the code, to verify that you are indeed talking to
+   the right server. This is sometimes somewhat impractical. Especially
+   if you do not know the server in advance; or if your code needs to be
+   stable ovr very long times - during which the server may change.
+
+   However completely dispensing with any checks (See the WifiClientInSecure
+   example) is also not a good idea either.
+
+   This example gives you some middle ground; "Trust on First Use" --
+   TOFU - see https://developer.mozilla.org/en-US/docs/Glossary/TOFU or
+   https://en.wikipedia.org/wiki/Trust_on_first_use).
+
+   In this scheme; we start the very first time without any security checks
+   but once we have our first connection; we store the public crytpographic
+   details (or a proxy, such as a sha256 of this). And then we use this for
+   any subsequent connections.
+
+   The assumption here is that we do our very first connection in a somewhat
+   trusted network environment; where the chance of a man in the middle is
+   very low; or one where the person doing the first run can check the
+   details manually.
+
+   So this is not quite as good as building a CA certificate into your
+   code (as per the WifiClientSecure example). But not as bad as something
+   with no trust management at all.
+
+   To make it possible for the enduser to 'reset' this trust; the
+   startup sequence checks if a certain GPIO is low (assumed to be wired
+   to some physical button or jumper on the PCB). And we only allow
+   the TOFU to be configured when this pin is LOW.
+*/
+#ifndef WIFI_NETWORK
+#define WIFI_NETWORK "Your Wifi SSID"
+#endif
+
+#ifndef WIFI_PASSWD
+#define WIFI_PASSWD "your-secret-wifi-password"
+#endif
+
+const char *ssid = WIFI_NETWORK;           // your network SSID (name of wifi network)
+const char *password = WIFI_PASSWD;        // your network password
+const char *server = "www.howsmyssl.com";  // Server to test with.
+
+const int TOFU_RESET_BUTTON = 35; /* Trust reset button wired between GPIO 35 and GND (pulldown) */
+
+#include <WiFi.h>
+#include <NetworkClientSecure.h>
+#include <EEPROM.h>
+
+/* Set aside some persistent memory (i.e. memory that is preserved on reboots and
+  power cycling; and will generally survive software updates as well.
+*/
+EEPROMClass TOFU("tofu0");
+
+// Utility function; checks if a given buffer is entirely
+// with with 0 bytes over its full length. Returns 0 on
+// success; a non zero value on fail.
+//
+static int memcmpzero(unsigned char *ptr, size_t len) {
+  while (len--) {
+    if (0xff != *ptr++) {
+      return -1;
+    }
+  }
+  return 0;
+};
+
+static void printSHA256(unsigned char *ptr) {
+  for (int i = 0; i < 32; i++) {
+    Serial.printf("%s%02x", i ? ":" : "", ptr[i]);
+  }
+  Serial.println("");
+};
+
+NetworkClientSecure client;
+
+bool get_tofu();
+bool doTOFU_Protected_Connection(uint8_t *fingerprint_tofu);
+
+void setup() {
+  bool tofu_reset = false;
+  //Initialize serial and wait for port to open:
+  Serial.begin(115200);
+  delay(100);
+
+  if (!TOFU.begin(32)) {
+    Serial.println("Could not initialsize the EEPROM");
+    return;
+  }
+  uint8_t fingerprint_tofu[32];
+
+  // reset the trust if the tofu reset button is pressed.
+  //
+  pinMode(TOFU_RESET_BUTTON, INPUT_PULLUP);
+  if (digitalRead(TOFU_RESET_BUTTON) == LOW) {
+    Serial.println("The TOFU reset button is pressed.");
+    tofu_reset = true;
+  }
+  /* if the button is not pressed; see if we can get the TOFU
+      fingerprint from the EEPROM.
+  */
+  else if (32 != TOFU.readBytes(0, fingerprint_tofu, 32)) {
+    Serial.println("Failed to get the fingerprint from memory.");
+    tofu_reset = true;
+  }
+  /* And check that the EEPROM value is not all 0's; in which
+      case we also need to do a TOFU.
+  */
+  else if (!memcmpzero(fingerprint_tofu, 32)) {
+    Serial.println("TOFU fingerprint in memory all zero.");
+    tofu_reset = true;
+  };
+  if (!tofu_reset) {
+    Serial.print("TOFU pegged to fingerprint: SHA256=");
+    printSHA256(fingerprint_tofu);
+    Serial.print("Note: You can check this fingerprint by going to the URL\n"
+                 "<https://");
+    Serial.print(server);
+    Serial.println("> and then click on the lock icon.\n");
+  };
+
+  // attempt to connect to Wifi network:
+  Serial.print("Attempting to connect to SSID: ");
+  Serial.println(ssid);
+  WiFi.begin(ssid, password);
+  while (WiFi.status() != WL_CONNECTED) {
+    Serial.print(".");
+    // wait 1 second for re-trying
+    delay(1000);
+  }
+
+  Serial.print("Connected to ");
+  Serial.println(ssid);
+
+  if (tofu_reset) {
+    Serial.println("Resetting trust fingerprint.");
+    if (!get_tofu()) {
+      Serial.println("Trust reset failed. Giving up");
+      return;
+    }
+    Serial.println("(New) Trust of First used configured. Rebooting in 3 seconds");
+    delay(3 * 1000);
+    ESP.restart();
+  };
+
+  Serial.println("Trying to connect to a server; using TOFU details from the eeprom");
+
+  if (doTOFU_Protected_Connection(fingerprint_tofu)) {
+    Serial.println("ALL OK");
+  }
+}
+
+bool get_tofu() {
+  Serial.println("\nStarting our insecure connection to server...");
+  client.setInsecure();  //skip verification
+
+  if (!client.connect(server, 443)) {
+    Serial.println("Connection failed!");
+    client.stop();
+    return false;
+  };
+
+  Serial.println("Connected to server. Extracting trust data.");
+
+  // Now extract the data of the certificate and show it to
+  // the user over the serial connection for optional
+  // verification.
+  const mbedtls_x509_crt *peer = client.getPeerCertificate();
+  char buf[1024];
+  int l = mbedtls_x509_crt_info(buf, sizeof(buf), "", peer);
+  if (l <= 0) {
+    Serial.println("Peer conversion to printable buffer failed");
+    client.stop();
+    return false;
+  };
+  Serial.println();
+  Serial.println(buf);
+
+  // Extract the fingerprint - and store this in our EEPROM
+  // to be used for future validation.
+
+  uint8_t fingerprint_remote[32];
+  if (!client.getFingerprintSHA256(fingerprint_remote)) {
+    Serial.println("Failed to get the fingerprint");
+    client.stop();
+    return false;
+  }
+  if ((32 != TOFU.writeBytes(0, fingerprint_remote, 32)) || (!TOFU.commit())) {
+    Serial.println("Could not write the fingerprint to the EEPROM");
+    client.stop();
+    return false;
+  };
+  TOFU.end();
+  client.stop();
+
+  Serial.print("TOFU pegged to fingerprint: SHA256=");
+  printSHA256(fingerprint_remote);
+
+  return true;
+};
+
+bool doTOFU_Protected_Connection(uint8_t *fingerprint_tofu) {
+
+  // As we're not using a (CA) certificate to check the
+  // connection; but the hash of the peer - we need to initially
+  // allow the connection to be set up without the CA check.
+  client.setInsecure();  //skip verification
+
+  if (!client.connect(server, 443)) {
+    Serial.println("Connection failed!");
+    client.stop();
+    return false;
+  };
+
+  // Now that we're connected - we can check that we have
+  // end to end trust - by comparing the fingerprint we (now)
+  // see (of the server certificate) to the one we have stored
+  // in our EEPROM as part of an earlier trust-on-first use.
+  uint8_t fingerprint_remote[32];
+  if (!client.getFingerprintSHA256(fingerprint_remote)) {
+    Serial.println("Failed to get the fingerprint of the server");
+    client.stop();
+    return false;
+  }
+  if (memcmp(fingerprint_remote, fingerprint_tofu, 32)) {
+    Serial.println("TOFU fingerprint not the same as the one from the server.");
+    Serial.print("TOFU  : SHA256=");
+    printSHA256(fingerprint_tofu);
+    Serial.print("Remote: SHA256=");
+    printSHA256(fingerprint_remote);
+    Serial.println("       : NOT identical -- Aborting!");
+    client.stop();
+    return false;
+  };
+
+  Serial.println("All well - you are talking to the same server as\n"
+                 "when you set up TOFU. So we can now do a GET.\n\n");
+
+  client.println("GET /a/check HTTP/1.0");
+  client.print("Host: ");
+  client.println(server);
+  client.println("Connection: close");
+  client.println();
+
+  bool inhdr = true;
+  while (client.connected()) {
+    String line = client.readStringUntil('\n');
+    Serial.println(line);
+    if (inhdr && line == "\r") {
+      inhdr = false;
+      Serial.println("-- headers received. Payload follows\n\n");
+    }
+  }
+  Serial.println("\n\n-- Payload ended.");
+  client.stop();
+  return true;
+}
+
+void loop() {}

lib/NetworkClientSecure/examples/WiFiClientTrustOnFirstUse/ci.json

@@ -0,0 +1,5 @@
+{
+  "targets": {
+    "esp32h2": false
+  }
+}

lib/NetworkClientSecure/keywords.txt

@@ -0,0 +1,36 @@
+#######################################
+# Syntax Coloring Map For WiFi
+#######################################
+
+#######################################
+# Library (KEYWORD3)
+#######################################
+
+NetworkClientSecure	KEYWORD3
+
+#######################################
+# Datatypes (KEYWORD1)
+#######################################
+
+NetworkClientSecure	KEYWORD1
+
+#######################################
+# Methods and Functions (KEYWORD2)
+#######################################
+
+connect	KEYWORD2
+write	KEYWORD2
+available	KEYWORD2
+config	KEYWORD2
+read	KEYWORD2
+flush	KEYWORD2
+stop	KEYWORD2
+connected	KEYWORD2
+setCACert	KEYWORD2
+setCertificate	KEYWORD2
+setPrivateKey	KEYWORD2
+setAlpnProtocols	KEYWORD2
+
+#######################################
+# Constants (LITERAL1)
+#######################################

lib/NetworkClientSecure/library.properties

@@ -0,0 +1,9 @@
+name=NetworkClientSecure
+version=2.0.0
+author=Evandro Luis Copercini
+maintainer=Github Community
+sentence=Enables secure network connection (local and Internet) using the ESP32 built-in WiFi.
+paragraph=With this library you can make a TLS or SSL connection to a remote server.
+category=Communication
+url=
+architectures=esp32

lib/NetworkClientSecure/src/NetworkClientSecure.cpp

@@ -0,0 +1,453 @@
+/*
+  NetworkClientSecure.cpp - Client Secure class for ESP32
+  Copyright (c) 2016 Hristo Gochkov  All right reserved.
+  Additions Copyright (C) 2017 Evandro Luis Copercini.
+
+  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
+*/
+
+#include "NetworkClientSecure.h"
+#include "esp_crt_bundle.h"
+#include <lwip/sockets.h>
+#include <lwip/netdb.h>
+#include <errno.h>
+
+#undef connect
+#undef write
+#undef read
+
+NetworkClientSecure::NetworkClientSecure() {
+  _connected = false;
+  _timeout = 30000;  // Same default as ssl_client
+
+  sslclient.reset(new sslclient_context, [](struct sslclient_context *sslclient) {
+    stop_ssl_socket(sslclient);
+    delete sslclient;
+  });
+  ssl_init(sslclient.get());
+  sslclient->socket = -1;
+  sslclient->handshake_timeout = 120000;
+  _use_insecure = false;
+  _stillinPlainStart = false;
+  _ca_cert_free = false;
+  _cert_free = false;
+  _private_key_free = false;
+  _CA_cert = NULL;
+  _cert = NULL;
+  _private_key = NULL;
+  _pskIdent = NULL;
+  _psKey = NULL;
+  next = NULL;
+  _alpn_protos = NULL;
+  _use_ca_bundle = false;
+}
+
+NetworkClientSecure::NetworkClientSecure(int sock) {
+  _connected = false;
+  _timeout = 30000;  // Same default as ssl_client
+  _lastReadTimeout = 0;
+  _lastWriteTimeout = 0;
+
+  sslclient.reset(new sslclient_context, [](struct sslclient_context *sslclient) {
+    stop_ssl_socket(sslclient);
+    delete sslclient;
+  });
+  ssl_init(sslclient.get());
+  sslclient->socket = sock;
+  sslclient->handshake_timeout = 120000;
+
+  if (sock >= 0) {
+    _connected = true;
+  }
+
+  _use_insecure = false;
+  _stillinPlainStart = false;
+  _ca_cert_free = false;
+  _cert_free = false;
+  _private_key_free = false;
+  _CA_cert = NULL;
+  _cert = NULL;
+  _private_key = NULL;
+  _pskIdent = NULL;
+  _psKey = NULL;
+  next = NULL;
+  _alpn_protos = NULL;
+}
+
+NetworkClientSecure::~NetworkClientSecure() {
+  if (_ca_cert_free && _CA_cert) {
+    free((void *)_CA_cert);
+  }
+  if (_cert_free && _cert) {
+    free((void *)_cert);
+  }
+  if (_private_key_free && _private_key) {
+    free((void *)_private_key);
+  }
+}
+
+void NetworkClientSecure::stop() {
+  stop_ssl_socket(sslclient.get());
+
+  _connected = false;
+  sslclient->peek_buf = -1;
+  _lastReadTimeout = 0;
+  _lastWriteTimeout = 0;
+}
+
+int NetworkClientSecure::connect(IPAddress ip, uint16_t port) {
+  if (_pskIdent && _psKey) {
+    return connect(ip, port, _pskIdent, _psKey);
+  }
+  return connect(ip, port, _CA_cert, _cert, _private_key);
+}
+
+int NetworkClientSecure::connect(IPAddress ip, uint16_t port, int32_t timeout) {
+  _timeout = timeout;
+  return connect(ip, port);
+}
+
+int NetworkClientSecure::connect(const char *host, uint16_t port) {
+  if (_pskIdent && _psKey) {
+    return connect(host, port, _pskIdent, _psKey);
+  }
+  return connect(host, port, _CA_cert, _cert, _private_key);
+}
+
+int NetworkClientSecure::connect(const char *host, uint16_t port, int32_t timeout) {
+  _timeout = timeout;
+  return connect(host, port);
+}
+
+int NetworkClientSecure::connect(IPAddress ip, uint16_t port, const char *CA_cert, const char *cert, const char *private_key) {
+  return connect(ip, port, NULL, CA_cert, cert, private_key);
+}
+
+int NetworkClientSecure::connect(const char *host, uint16_t port, const char *CA_cert, const char *cert, const char *private_key) {
+  IPAddress address;
+  if (!Network.hostByName(host, address)) {
+    return 0;
+  }
+
+  return connect(address, port, host, CA_cert, cert, private_key);
+}
+
+int NetworkClientSecure::connect(IPAddress ip, uint16_t port, const char *host, const char *CA_cert, const char *cert, const char *private_key) {
+  int ret = start_ssl_client(sslclient.get(), ip, port, host, _timeout, CA_cert, _use_ca_bundle, cert, private_key, NULL, NULL, _use_insecure, _alpn_protos);
+
+  if (ret >= 0 && !_stillinPlainStart) {
+    ret = ssl_starttls_handshake(sslclient.get());
+  } else {
+    log_i("Actual TLS start postponed.");
+  }
+
+  sslclient->last_error = ret;
+
+  if (ret < 0) {
+    log_e("start_ssl_client: connect failed: %d", ret);
+    stop();
+    return 0;
+  }
+  _connected = true;
+  return 1;
+}
+
+int NetworkClientSecure::startTLS() {
+  int ret = 1;
+  if (_stillinPlainStart) {
+    log_i("startTLS: starting TLS/SSL on this dplain connection");
+    ret = ssl_starttls_handshake(sslclient.get());
+    if (ret < 0) {
+      log_e("startTLS: %d", ret);
+      stop();
+      return 0;
+    };
+    _stillinPlainStart = false;
+  } else {
+    log_i("startTLS: ignoring StartTLS - as we should be secure already");
+  }
+  return 1;
+}
+
+int NetworkClientSecure::connect(IPAddress ip, uint16_t port, const char *pskIdent, const char *psKey) {
+  return connect(ip.toString().c_str(), port, pskIdent, psKey);
+}
+
+int NetworkClientSecure::connect(const char *host, uint16_t port, const char *pskIdent, const char *psKey) {
+  log_v("start_ssl_client with PSK");
+
+  IPAddress address;
+  if (!Network.hostByName(host, address)) {
+    return 0;
+  }
+
+  int ret = start_ssl_client(sslclient.get(), address, port, host, _timeout, NULL, false, NULL, NULL, pskIdent, psKey, _use_insecure, _alpn_protos);
+  sslclient->last_error = ret;
+  if (ret < 0) {
+    log_e("start_ssl_client: connect failed %d", ret);
+    stop();
+    return 0;
+  }
+  _connected = true;
+  return 1;
+}
+
+int NetworkClientSecure::peek() {
+  if (sslclient->peek_buf >= 0) {
+    return sslclient->peek_buf;
+  }
+  sslclient->peek_buf = timedRead();
+  return sslclient->peek_buf;
+}
+
+size_t NetworkClientSecure::write(uint8_t data) {
+  return write(&data, 1);
+}
+
+int NetworkClientSecure::read() {
+  uint8_t data = -1;
+  int res = read(&data, 1);
+  return res < 0 ? res : data;
+}
+
+size_t NetworkClientSecure::write(const uint8_t *buf, size_t size) {
+  if (!_connected) {
+    return 0;
+  }
+
+  if (_stillinPlainStart) {
+    return send_net_data(sslclient.get(), buf, size);
+  }
+
+  if (_lastWriteTimeout != _timeout) {
+    struct timeval timeout_tv;
+    timeout_tv.tv_sec = _timeout / 1000;
+    timeout_tv.tv_usec = (_timeout % 1000) * 1000;
+    if (setSocketOption(SO_SNDTIMEO, (char *)&timeout_tv, sizeof(struct timeval)) >= 0) {
+      _lastWriteTimeout = _timeout;
+    }
+  }
+  int res = send_ssl_data(sslclient.get(), buf, size);
+  if (res < 0) {
+    log_e("Closing connection on failed write");
+    stop();
+    res = 0;
+  }
+  return res;
+}
+
+int NetworkClientSecure::read(uint8_t *buf, size_t size) {
+  if (_stillinPlainStart) {
+    return get_net_receive(sslclient.get(), buf, size);
+  }
+
+  if (_lastReadTimeout != _timeout) {
+    if (fd() >= 0) {
+      struct timeval timeout_tv;
+      timeout_tv.tv_sec = _timeout / 1000;
+      timeout_tv.tv_usec = (_timeout % 1000) * 1000;
+      if (setSocketOption(SO_RCVTIMEO, (char *)&timeout_tv, sizeof(struct timeval)) >= 0) {
+        _lastReadTimeout = _timeout;
+      }
+    }
+  }
+
+  int peeked = 0, res = -1;
+  int avail = available();
+  if ((!buf && size) || avail <= 0) {
+    return -1;
+  }
+  if (!size) {
+    return 0;
+  }
+  if (sslclient->peek_buf >= 0) {
+    buf[0] = sslclient->peek_buf;
+    sslclient->peek_buf = -1;
+    size--;
+    avail--;
+    if (!size || !avail) {
+      return 1;
+    }
+    buf++;
+    peeked = 1;
+  }
+  res = get_ssl_receive(sslclient.get(), buf, size);
+
+  if (res < 0) {
+    log_e("Closing connection on failed read");
+    stop();
+    return peeked ? peeked : res;
+  }
+  return res + peeked;
+}
+
+int NetworkClientSecure::available() {
+  if (_stillinPlainStart) {
+    return peek_net_receive(sslclient.get(), 0);
+  }
+
+  int peeked = (sslclient->peek_buf >= 0), res = -1;
+  if (!_connected) {
+    return peeked;
+  }
+  res = data_to_read(sslclient.get());
+
+  if (res < 0 && !_stillinPlainStart) {
+    log_e("Closing connection on failed available check");
+    stop();
+    return peeked ? peeked : res;
+  }
+  return res + peeked;
+}
+
+uint8_t NetworkClientSecure::connected() {
+  uint8_t dummy = 0;
+  read(&dummy, 0);
+
+  return _connected;
+}
+
+void NetworkClientSecure::setInsecure() {
+  _CA_cert = NULL;
+  _cert = NULL;
+  _private_key = NULL;
+  _pskIdent = NULL;
+  _psKey = NULL;
+  _use_insecure = true;
+}
+
+void NetworkClientSecure::setCACert(const char *rootCA) {
+  if (_ca_cert_free && _CA_cert) {
+    free((void *)_CA_cert);
+    _ca_cert_free = false;
+  }
+  _CA_cert = rootCA;
+  _use_insecure = false;
+}
+
+void NetworkClientSecure::setCACertBundle(const uint8_t *bundle) {
+  if (bundle != NULL) {
+    esp_crt_bundle_set(bundle, sizeof(bundle));
+    attach_ssl_certificate_bundle(sslclient.get(), true);
+    _use_ca_bundle = true;
+  } else {
+    esp_crt_bundle_detach(NULL);
+    attach_ssl_certificate_bundle(sslclient.get(), false);
+    _use_ca_bundle = false;
+  }
+}
+
+void NetworkClientSecure::setCertificate(const char *client_ca) {
+  if (_cert_free && _cert) {
+    free((void *)_cert);
+    _cert_free = false;
+  }
+  _cert = client_ca;
+}
+
+void NetworkClientSecure::setPrivateKey(const char *private_key) {
+  if (_private_key_free && _private_key) {
+    free((void *)_private_key);
+    _private_key_free = false;
+  }
+  _private_key = private_key;
+}
+
+void NetworkClientSecure::setPreSharedKey(const char *pskIdent, const char *psKey) {
+  _pskIdent = pskIdent;
+  _psKey = psKey;
+}
+
+bool NetworkClientSecure::verify(const char *fp, const char *domain_name) {
+  if (!sslclient) {
+    return false;
+  }
+
+  return verify_ssl_fingerprint(sslclient.get(), fp, domain_name);
+}
+
+char *NetworkClientSecure::_streamLoad(Stream &stream, size_t size) {
+  char *dest = (char *)malloc(size + 1);
+  if (!dest) {
+    return nullptr;
+  }
+  if (size != stream.readBytes(dest, size)) {
+    free(dest);
+    dest = nullptr;
+    return nullptr;
+  }
+  dest[size] = '\0';
+  return dest;
+}
+
+bool NetworkClientSecure::loadCACert(Stream &stream, size_t size) {
+  if (_CA_cert != NULL) {
+    free(const_cast<char *>(_CA_cert));
+  }
+  char *dest = _streamLoad(stream, size);
+  bool ret = false;
+  if (dest) {
+    setCACert(dest);
+    _ca_cert_free = true;
+    ret = true;
+  }
+  return ret;
+}
+
+bool NetworkClientSecure::loadCertificate(Stream &stream, size_t size) {
+  if (_cert != NULL) {
+    free(const_cast<char *>(_cert));
+  }
+  char *dest = _streamLoad(stream, size);
+  bool ret = false;
+  if (dest) {
+    setCertificate(dest);
+    _cert_free = true;
+    ret = true;
+  }
+  return ret;
+}
+
+bool NetworkClientSecure::loadPrivateKey(Stream &stream, size_t size) {
+  if (_private_key != NULL) {
+    free(const_cast<char *>(_private_key));
+  }
+  char *dest = _streamLoad(stream, size);
+  bool ret = false;
+  if (dest) {
+    setPrivateKey(dest);
+    _private_key_free = true;
+    ret = true;
+  }
+  return ret;
+}
+
+int NetworkClientSecure::lastError(char *buf, const size_t size) {
+  int lastError = sslclient->last_error;
+  mbedtls_strerror(lastError, buf, size);
+  return lastError;
+}
+
+void NetworkClientSecure::setHandshakeTimeout(unsigned long handshake_timeout) {
+  sslclient->handshake_timeout = handshake_timeout * 1000;
+}
+
+void NetworkClientSecure::setAlpnProtocols(const char **alpn_protos) {
+  _alpn_protos = alpn_protos;
+}
+
+int NetworkClientSecure::fd() const {
+  return sslclient->socket;
+}

lib/NetworkClientSecure/src/NetworkClientSecure.h

@@ -0,0 +1,131 @@
+/*
+  NetworkClientSecure.h - Base class that provides Client SSL to ESP32
+  Copyright (c) 2011 Adrian McEwen.  All right reserved.
+  Additions Copyright (C) 2017 Evandro Luis Copercini.
+
+  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 NetworkClientSecure_h
+#define NetworkClientSecure_h
+#include "Arduino.h"
+#include "IPAddress.h"
+#include "Network.h"
+#include "ssl_client.h"
+#include <memory>
+
+class NetworkClientSecure : public NetworkClient {
+protected:
+  std::shared_ptr<sslclient_context> sslclient;
+
+  bool _use_insecure;
+  bool _stillinPlainStart;
+  bool _ca_cert_free;
+  bool _cert_free;
+  bool _private_key_free;
+  const char *_CA_cert;
+  const char *_cert;
+  const char *_private_key;
+  const char *_pskIdent;  // identity for PSK cipher suites
+  const char *_psKey;     // key in hex for PSK cipher suites
+  const char **_alpn_protos;
+  bool _use_ca_bundle;
+
+public:
+  NetworkClientSecure *next;
+  NetworkClientSecure();
+  NetworkClientSecure(int socket);
+  ~NetworkClientSecure();
+  int connect(IPAddress ip, uint16_t port);
+  int connect(IPAddress ip, uint16_t port, int32_t timeout);
+  int connect(const char *host, uint16_t port);
+  int connect(const char *host, uint16_t port, int32_t timeout);
+  int connect(IPAddress ip, uint16_t port, const char *rootCABuff, const char *cli_cert, const char *cli_key);
+  int connect(const char *host, uint16_t port, const char *rootCABuff, const char *cli_cert, const char *cli_key);
+  int connect(IPAddress ip, uint16_t port, const char *pskIdent, const char *psKey);
+  int connect(const char *host, uint16_t port, const char *pskIdent, const char *psKey);
+  int connect(IPAddress ip, uint16_t port, const char *host, const char *CA_cert, const char *cert, const char *private_key);
+  int peek();
+  size_t write(uint8_t data);
+  size_t write(const uint8_t *buf, size_t size);
+  int available();
+  int read();
+  int read(uint8_t *buf, size_t size);
+  void flush() {}
+  void stop();
+  uint8_t connected();
+  int lastError(char *buf, const size_t size);
+  void setInsecure();                                             // Don't validate the chain, just accept whatever is given.  VERY INSECURE!
+  void setPreSharedKey(const char *pskIdent, const char *psKey);  // psKey in Hex
+  void setCACert(const char *rootCA);
+  void setCertificate(const char *client_ca);
+  void setPrivateKey(const char *private_key);
+  bool loadCACert(Stream &stream, size_t size);
+  void setCACertBundle(const uint8_t *bundle);
+  bool loadCertificate(Stream &stream, size_t size);
+  bool loadPrivateKey(Stream &stream, size_t size);
+  bool verify(const char *fingerprint, const char *domain_name);
+  void setHandshakeTimeout(unsigned long handshake_timeout);
+  void setAlpnProtocols(const char **alpn_protos);
+
+  // Certain protocols start in plain-text; and then have the client
+  // give some STARTSSL command to `upgrade' the connection to TLS
+  // or SSL. Setting PlainStart to true (the default is false) enables
+  // this. It is up to the application code to then call 'startTLS()'
+  // at the right point to initialize the SSL or TLS upgrade.
+
+  void setPlainStart() {
+    _stillinPlainStart = true;
+  };
+  bool stillInPlainStart() {
+    return _stillinPlainStart;
+  };
+  int startTLS();
+
+  const mbedtls_x509_crt *getPeerCertificate() {
+    return mbedtls_ssl_get_peer_cert(&sslclient->ssl_ctx);
+  };
+  bool getFingerprintSHA256(uint8_t sha256_result[32]) {
+    return get_peer_fingerprint(sslclient.get(), sha256_result);
+  };
+  int fd() const;
+
+  operator bool() {
+    return connected();
+  }
+
+  bool operator==(const bool value) {
+    return bool() == value;
+  }
+  bool operator!=(const bool value) {
+    return bool() != value;
+  }
+  bool operator==(const NetworkClientSecure &);
+  bool operator!=(const NetworkClientSecure &rhs) {
+    return !this->operator==(rhs);
+  };
+
+  int socket() {
+    return sslclient->socket = -1;
+  }
+
+private:
+  char *_streamLoad(Stream &stream, size_t size);
+
+  //friend class NetworkServer;
+  using Print::write;
+};
+
+#endif /* _WIFICLIENT_H_ */

lib/NetworkClientSecure/src/WiFiClientSecure.h

@@ -0,0 +1,3 @@
+#pragma once
+#include "NetworkClientSecure.h"
+#define WiFiClientSecure NetworkClientSecure

lib/NetworkClientSecure/src/ssl_client.cpp

@@ -0,0 +1,633 @@
+/* Provide SSL/TLS functions to ESP32 with Arduino IDE
+*
+* Adapted from the ssl_client1 example of mbedtls.
+*
+* Original Copyright (C) 2006-2015, ARM Limited, All Rights Reserved, Apache 2.0 License.
+* Additions Copyright (C) 2017 Evandro Luis Copercini, Apache 2.0 License.
+*/
+
+#include "Arduino.h"
+#include <esp32-hal-log.h>
+#include <lwip/err.h>
+#include <lwip/sockets.h>
+#include <lwip/sys.h>
+#include <lwip/netdb.h>
+#include <mbedtls/sha256.h>
+#include <mbedtls/oid.h>
+#include <algorithm>
+#include <string>
+#include "ssl_client.h"
+#include "esp_crt_bundle.h"
+
+#if !defined(MBEDTLS_KEY_EXCHANGE__SOME__PSK_ENABLED) && !defined(MBEDTLS_KEY_EXCHANGE_SOME_PSK_ENABLED)
+#warning \
+  "Please call `idf.py menuconfig` then go to Component config -> mbedTLS -> TLS Key Exchange Methods -> Enable pre-shared-key ciphersuites and then check `Enable PSK based ciphersuite modes`. Save and Quit."
+#else
+
+const char *pers = "esp32-tls";
+
+static int _handle_error(int err, const char *function, int line) {
+  if (err == -30848) {
+    return err;
+  }
+#ifdef MBEDTLS_ERROR_C
+  char error_buf[100];
+  mbedtls_strerror(err, error_buf, 100);
+  log_e("[%s():%d]: (%d) %s", function, line, err, error_buf);
+#else
+  log_e("[%s():%d]: code %d", function, line, err);
+#endif
+  return err;
+}
+
+#define handle_error(e) _handle_error(e, __FUNCTION__, __LINE__)
+
+void ssl_init(sslclient_context *ssl_client) {
+  // reset embedded pointers to zero
+  memset(ssl_client, 0, sizeof(sslclient_context));
+  mbedtls_ssl_init(&ssl_client->ssl_ctx);
+  mbedtls_ssl_config_init(&ssl_client->ssl_conf);
+  mbedtls_ctr_drbg_init(&ssl_client->drbg_ctx);
+  ssl_client->peek_buf = -1;
+}
+
+void attach_ssl_certificate_bundle(sslclient_context *ssl_client, bool att) {
+  if (att) {
+    ssl_client->bundle_attach_cb = &esp_crt_bundle_attach;
+  } else {
+    ssl_client->bundle_attach_cb = NULL;
+  }
+}
+
+int start_ssl_client(
+  sslclient_context *ssl_client, const IPAddress &ip, uint32_t port, const char *hostname, int timeout, const char *rootCABuff, bool useRootCABundle,
+  const char *cli_cert, const char *cli_key, const char *pskIdent, const char *psKey, bool insecure, const char **alpn_protos
+) {
+  int ret;
+  int enable = 1;
+  log_v("Free internal heap before TLS %u", ESP.getFreeHeap());
+
+  if (rootCABuff == NULL && pskIdent == NULL && psKey == NULL && !insecure && !useRootCABundle) {
+    return -1;
+  }
+
+  int domain = ip.type() == IPv6 ? AF_INET6 : AF_INET;
+  log_v("Starting socket (domain %d)", domain);
+  ssl_client->socket = -1;
+
+  ssl_client->socket = lwip_socket(domain, SOCK_STREAM, IPPROTO_TCP);
+  if (ssl_client->socket < 0) {
+    log_e("ERROR opening socket");
+    return ssl_client->socket;
+  }
+
+  fcntl(ssl_client->socket, F_SETFL, fcntl(ssl_client->socket, F_GETFL, 0) | O_NONBLOCK);
+  struct sockaddr_storage serv_addr = {};
+  if (domain == AF_INET6) {
+    struct sockaddr_in6 *tmpaddr = (struct sockaddr_in6 *)&serv_addr;
+    tmpaddr->sin6_family = AF_INET6;
+    for (int index = 0; index < 16; index++) {
+      tmpaddr->sin6_addr.s6_addr[index] = ip[index];
+    }
+    tmpaddr->sin6_port = htons(port);
+    tmpaddr->sin6_scope_id = ip.zone();
+  } else {
+    struct sockaddr_in *tmpaddr = (struct sockaddr_in *)&serv_addr;
+    tmpaddr->sin_family = AF_INET;
+    tmpaddr->sin_addr.s_addr = ip;
+    tmpaddr->sin_port = htons(port);
+  }
+
+  if (timeout <= 0) {
+    timeout = 30000;  // Milli seconds.
+  }
+
+  ssl_client->socket_timeout = timeout;
+
+  fd_set fdset;
+  struct timeval tv;
+  FD_ZERO(&fdset);
+  FD_SET(ssl_client->socket, &fdset);
+  tv.tv_sec = timeout / 1000;
+  tv.tv_usec = (timeout % 1000) * 1000;
+
+  int res = lwip_connect(ssl_client->socket, (struct sockaddr *)&serv_addr, sizeof(serv_addr));
+  if (res < 0 && errno != EINPROGRESS) {
+    log_e("connect on fd %d, errno: %d, \"%s\"", ssl_client->socket, errno, strerror(errno));
+    lwip_close(ssl_client->socket);
+    ssl_client->socket = -1;
+    return -1;
+  }
+
+  res = select(ssl_client->socket + 1, nullptr, &fdset, nullptr, timeout < 0 ? nullptr : &tv);
+  if (res < 0) {
+    log_e("select on fd %d, errno: %d, \"%s\"", ssl_client->socket, errno, strerror(errno));
+    lwip_close(ssl_client->socket);
+    ssl_client->socket = -1;
+    return -1;
+  } else if (res == 0) {
+    log_i("select returned due to timeout %d ms for fd %d", timeout, ssl_client->socket);
+    lwip_close(ssl_client->socket);
+    ssl_client->socket = -1;
+    return -1;
+  } else {
+    int sockerr;
+    socklen_t len = (socklen_t)sizeof(int);
+    res = getsockopt(ssl_client->socket, SOL_SOCKET, SO_ERROR, &sockerr, &len);
+
+    if (res < 0) {
+      log_e("getsockopt on fd %d, errno: %d, \"%s\"", ssl_client->socket, errno, strerror(errno));
+      lwip_close(ssl_client->socket);
+      ssl_client->socket = -1;
+      return -1;
+    }
+
+    if (sockerr != 0) {
+      log_e("socket error on fd %d, errno: %d, \"%s\"", ssl_client->socket, sockerr, strerror(sockerr));
+      lwip_close(ssl_client->socket);
+      ssl_client->socket = -1;
+      return -1;
+    }
+  }
+
+#define ROE(x, msg)                                   \
+  {                                                   \
+    if (((x) < 0)) {                                  \
+      log_e("LWIP Socket config of " msg " failed."); \
+      return -1;                                      \
+    }                                                 \
+  }
+  ROE(lwip_setsockopt(ssl_client->socket, SOL_SOCKET, SO_RCVTIMEO, &tv, sizeof(tv)), "SO_RCVTIMEO");
+  ROE(lwip_setsockopt(ssl_client->socket, SOL_SOCKET, SO_SNDTIMEO, &tv, sizeof(tv)), "SO_SNDTIMEO");
+
+  ROE(lwip_setsockopt(ssl_client->socket, IPPROTO_TCP, TCP_NODELAY, &enable, sizeof(enable)), "TCP_NODELAY");
+  ROE(lwip_setsockopt(ssl_client->socket, SOL_SOCKET, SO_KEEPALIVE, &enable, sizeof(enable)), "SO_KEEPALIVE");
+
+  log_v("Seeding the random number generator");
+  mbedtls_entropy_init(&ssl_client->entropy_ctx);
+
+  ret = mbedtls_ctr_drbg_seed(&ssl_client->drbg_ctx, mbedtls_entropy_func, &ssl_client->entropy_ctx, (const unsigned char *)pers, strlen(pers));
+  if (ret < 0) {
+    return handle_error(ret);
+  }
+
+  log_v("Setting up the SSL/TLS structure...");
+
+  if ((ret = mbedtls_ssl_config_defaults(&ssl_client->ssl_conf, MBEDTLS_SSL_IS_CLIENT, MBEDTLS_SSL_TRANSPORT_STREAM, MBEDTLS_SSL_PRESET_DEFAULT)) != 0) {
+    return handle_error(ret);
+  }
+
+  if (alpn_protos != NULL) {
+    log_v("Setting ALPN protocols");
+    if ((ret = mbedtls_ssl_conf_alpn_protocols(&ssl_client->ssl_conf, alpn_protos)) != 0) {
+      return handle_error(ret);
+    }
+  }
+
+  // MBEDTLS_SSL_VERIFY_REQUIRED if a CA certificate is defined on Arduino IDE and
+  // MBEDTLS_SSL_VERIFY_NONE if not.
+
+  if (insecure) {
+    mbedtls_ssl_conf_authmode(&ssl_client->ssl_conf, MBEDTLS_SSL_VERIFY_NONE);
+    log_d("WARNING: Skipping SSL Verification. INSECURE!");
+  } else if (rootCABuff != NULL) {
+    log_v("Loading CA cert");
+    mbedtls_x509_crt_init(&ssl_client->ca_cert);
+    mbedtls_ssl_conf_authmode(&ssl_client->ssl_conf, MBEDTLS_SSL_VERIFY_REQUIRED);
+    ret = mbedtls_x509_crt_parse(&ssl_client->ca_cert, (const unsigned char *)rootCABuff, strlen(rootCABuff) + 1);
+    mbedtls_ssl_conf_ca_chain(&ssl_client->ssl_conf, &ssl_client->ca_cert, NULL);
+    //mbedtls_ssl_conf_verify(&ssl_client->ssl_ctx, my_verify, NULL );
+    if (ret < 0) {
+      // free the ca_cert in the case parse failed, otherwise, the old ca_cert still in the heap memory, that lead to "out of memory" crash.
+      mbedtls_x509_crt_free(&ssl_client->ca_cert);
+      return handle_error(ret);
+    }
+  } else if (useRootCABundle) {
+    if (ssl_client->bundle_attach_cb != NULL) {
+      log_v("Attaching root CA cert bundle");
+      ret = ssl_client->bundle_attach_cb(&ssl_client->ssl_conf);
+      if (ret < 0) {
+        return handle_error(ret);
+      }
+    } else {
+      log_e("useRootCABundle is set, but attach_ssl_certificate_bundle(ssl, true); was not called!");
+    }
+  } else if (pskIdent != NULL && psKey != NULL) {
+    log_v("Setting up PSK");
+    // convert PSK from hex to binary
+    if ((strlen(psKey) & 1) != 0 || strlen(psKey) > 2 * MBEDTLS_PSK_MAX_LEN) {
+      log_e("pre-shared key not valid hex or too long");
+      return -1;
+    }
+    unsigned char psk[MBEDTLS_PSK_MAX_LEN];
+    size_t psk_len = strlen(psKey) / 2;
+    for (int j = 0; j < strlen(psKey); j += 2) {
+      char c = psKey[j];
+      if (c >= '0' && c <= '9') {
+        c -= '0';
+      } else if (c >= 'A' && c <= 'F') {
+        c -= 'A' - 10;
+      } else if (c >= 'a' && c <= 'f') {
+        c -= 'a' - 10;
+      } else {
+        return -1;
+      }
+      psk[j / 2] = c << 4;
+      c = psKey[j + 1];
+      if (c >= '0' && c <= '9') {
+        c -= '0';
+      } else if (c >= 'A' && c <= 'F') {
+        c -= 'A' - 10;
+      } else if (c >= 'a' && c <= 'f') {
+        c -= 'a' - 10;
+      } else {
+        return -1;
+      }
+      psk[j / 2] |= c;
+    }
+    // set mbedtls config
+    ret = mbedtls_ssl_conf_psk(&ssl_client->ssl_conf, psk, psk_len, (const unsigned char *)pskIdent, strlen(pskIdent));
+    if (ret != 0) {
+      log_e("mbedtls_ssl_conf_psk returned %d", ret);
+      return handle_error(ret);
+    }
+  } else {
+    return -1;
+  }
+
+  // Note - this check for BOTH key and cert is relied on
+  // later during cleanup.
+
+  if (!insecure && cli_cert != NULL && cli_key != NULL) {
+    mbedtls_x509_crt_init(&ssl_client->client_cert);
+    mbedtls_pk_init(&ssl_client->client_key);
+
+    log_v("Loading CRT cert");
+
+    ret = mbedtls_x509_crt_parse(&ssl_client->client_cert, (const unsigned char *)cli_cert, strlen(cli_cert) + 1);
+    if (ret < 0) {
+      // free the client_cert in the case parse failed, otherwise, the old client_cert still in the heap memory, that lead to "out of memory" crash.
+      mbedtls_x509_crt_free(&ssl_client->client_cert);
+      return handle_error(ret);
+    }
+
+    log_v("Loading private key");
+    mbedtls_ctr_drbg_context ctr_drbg;
+    mbedtls_ctr_drbg_init(&ctr_drbg);
+    ret = mbedtls_pk_parse_key(&ssl_client->client_key, (const unsigned char *)cli_key, strlen(cli_key) + 1, NULL, 0, mbedtls_ctr_drbg_random, &ctr_drbg);
+    mbedtls_ctr_drbg_free(&ctr_drbg);
+
+    if (ret != 0) {
+      mbedtls_x509_crt_free(&ssl_client->client_cert);  // cert+key are free'd in pair
+      return handle_error(ret);
+    }
+
+    mbedtls_ssl_conf_own_cert(&ssl_client->ssl_conf, &ssl_client->client_cert, &ssl_client->client_key);
+  }
+
+  log_v("Setting hostname for TLS session...");
+
+  // Hostname set here should match CN in server certificate
+  if ((ret = mbedtls_ssl_set_hostname(&ssl_client->ssl_ctx, hostname != NULL ? hostname : ip.toString().c_str())) != 0) {
+    return handle_error(ret);
+  }
+
+  mbedtls_ssl_conf_rng(&ssl_client->ssl_conf, mbedtls_ctr_drbg_random, &ssl_client->drbg_ctx);
+
+  if ((ret = mbedtls_ssl_setup(&ssl_client->ssl_ctx, &ssl_client->ssl_conf)) != 0) {
+    return handle_error(ret);
+  }
+
+  mbedtls_ssl_set_bio(&ssl_client->ssl_ctx, &ssl_client->socket, mbedtls_net_send, mbedtls_net_recv, NULL);
+  return ssl_client->socket;
+}
+
+int ssl_starttls_handshake(sslclient_context *ssl_client) {
+  char buf[512];
+  int ret, flags;
+
+  log_v("Performing the SSL/TLS handshake...");
+  unsigned long handshake_start_time = millis();
+  while ((ret = mbedtls_ssl_handshake(&ssl_client->ssl_ctx)) != 0) {
+    if (ret != MBEDTLS_ERR_SSL_WANT_READ && ret != MBEDTLS_ERR_SSL_WANT_WRITE) {
+      return handle_error(ret);
+    }
+    if ((millis() - handshake_start_time) > ssl_client->handshake_timeout) {
+      return -1;
+    }
+    vTaskDelay(2);  //2 ticks
+  }
+
+  if (ssl_client->client_cert.version) {
+    log_d("Protocol is %s Ciphersuite is %s", mbedtls_ssl_get_version(&ssl_client->ssl_ctx), mbedtls_ssl_get_ciphersuite(&ssl_client->ssl_ctx));
+    if ((ret = mbedtls_ssl_get_record_expansion(&ssl_client->ssl_ctx)) >= 0) {
+      log_d("Record expansion is %d", ret);
+    } else {
+      log_w("Record expansion is unknown (compression)");
+    }
+  }
+
+  log_v("Verifying peer X.509 certificate...");
+
+  if ((flags = mbedtls_ssl_get_verify_result(&ssl_client->ssl_ctx)) != 0) {
+    memset(buf, 0, sizeof(buf));
+    mbedtls_x509_crt_verify_info(buf, sizeof(buf), "  ! ", flags);
+    log_e("Failed to verify peer certificate! verification info: %s", buf);
+    return handle_error(ret);
+  } else {
+    log_v("Certificate verified.");
+  }
+
+  if (ssl_client->ca_cert.version) {
+    mbedtls_x509_crt_free(&ssl_client->ca_cert);
+  }
+
+  // We know that we always have a client cert/key pair -- and we
+  // cannot look into the private client_key pk struct for newer
+  // versions of mbedtls. So rely on a public field of the cert
+  // and infer that there is a key too.
+  if (ssl_client->client_cert.version) {
+    mbedtls_x509_crt_free(&ssl_client->client_cert);
+    mbedtls_pk_free(&ssl_client->client_key);
+  }
+
+  log_v("Free internal heap after TLS %u", ESP.getFreeHeap());
+
+  return ssl_client->socket;
+}
+
+void stop_ssl_socket(sslclient_context *ssl_client) {
+  log_v("Cleaning SSL connection.");
+
+  if (ssl_client->socket >= 0) {
+    lwip_close(ssl_client->socket);
+    ssl_client->socket = -1;
+  }
+
+  // avoid memory leak if ssl connection attempt failed
+  // if (ssl_client->ssl_conf.ca_chain != NULL) {
+  mbedtls_x509_crt_free(&ssl_client->ca_cert);
+  // }
+  // if (ssl_client->ssl_conf.key_cert != NULL) {
+  mbedtls_x509_crt_free(&ssl_client->client_cert);
+  mbedtls_pk_free(&ssl_client->client_key);
+  // }
+  mbedtls_ssl_free(&ssl_client->ssl_ctx);
+  mbedtls_ssl_config_free(&ssl_client->ssl_conf);
+  mbedtls_ctr_drbg_free(&ssl_client->drbg_ctx);
+  mbedtls_entropy_free(&ssl_client->entropy_ctx);
+
+  // save only interesting fields
+  int handshake_timeout = ssl_client->handshake_timeout;
+  int socket_timeout = ssl_client->socket_timeout;
+  int last_err = ssl_client->last_error;
+
+  // reset embedded pointers to zero
+  memset(ssl_client, 0, sizeof(sslclient_context));
+
+  ssl_client->handshake_timeout = handshake_timeout;
+  ssl_client->socket_timeout = socket_timeout;
+  ssl_client->last_error = last_err;
+  ssl_client->peek_buf = -1;
+}
+
+int data_to_read(sslclient_context *ssl_client) {
+  int ret, res;
+  ret = mbedtls_ssl_read(&ssl_client->ssl_ctx, NULL, 0);
+  //log_e("RET: %i",ret);   //for low level debug
+  res = mbedtls_ssl_get_bytes_avail(&ssl_client->ssl_ctx);
+  //log_e("RES: %i",res);    //for low level debug
+  if (ret != MBEDTLS_ERR_SSL_WANT_READ && ret != MBEDTLS_ERR_SSL_WANT_WRITE && ret < 0) {
+    return handle_error(ret);
+  }
+
+  return res;
+}
+
+int send_ssl_data(sslclient_context *ssl_client, const uint8_t *data, size_t len) {
+  unsigned long write_start_time = millis();
+  int ret = -1;
+
+  while ((ret = mbedtls_ssl_write(&ssl_client->ssl_ctx, data, len)) <= 0) {
+    if ((millis() - write_start_time) > ssl_client->socket_timeout) {
+      log_v("SSL write timed out.");
+      return -1;
+    }
+
+    if (ret != MBEDTLS_ERR_SSL_WANT_READ && ret != MBEDTLS_ERR_SSL_WANT_WRITE && ret < 0) {
+      log_v("Handling error %d", ret);  //for low level debug
+      return handle_error(ret);
+    }
+
+    //wait for space to become available
+    vTaskDelay(2);
+  }
+
+  return ret;
+}
+
+// Some protocols, such as SMTP, XMPP, MySQL/Posgress and various others
+// do a 'in-line' upgrade from plaintext to SSL or TLS (usually with some
+// sort of 'STARTTLS' textual command from client to sever). For this
+// we need to have access to the 'raw' socket; i.e. without TLS/SSL state
+// handling before the handshake starts; but after setting up the TLS
+// connection.
+//
+int peek_net_receive(sslclient_context *ssl_client, int timeout) {
+#if MBEDTLS_FIXED_LINKING_NET_POLL
+  int ret = mbedtls_net_poll((mbedtls_net_context *)ssl_client, MBEDTLS_NET_POLL_READ, timeout);
+  ret == MBEDTLS_NET_POLL_READ ? 1 : ret;
+#else
+  // We should be using mbedtls_net_poll(); which is part of mbedtls and
+  // included in the EspressifSDK. Unfortunately - it did not make it into
+  // the statically linked library file. So, for now, we replace it by
+  // substancially similar code.
+  //
+  struct timeval tv = {.tv_sec = timeout / 1000, .tv_usec = (timeout % 1000) * 1000};
+
+  fd_set fdset;
+  FD_SET(ssl_client->socket, &fdset);
+
+  int ret = select(ssl_client->socket + 1, &fdset, nullptr, nullptr, timeout < 0 ? nullptr : &tv);
+  if (ret < 0) {
+    log_e("select on read fd %d, errno: %d, \"%s\"", ssl_client->socket, errno, strerror(errno));
+    lwip_close(ssl_client->socket);
+    ssl_client->socket = -1;
+    return -1;
+  };
+#endif
+  return ret;
+};
+
+int get_net_receive(sslclient_context *ssl_client, uint8_t *data, int length) {
+  int ret = peek_net_receive(ssl_client, ssl_client->socket_timeout);
+  if (ret > 0) {
+    ret = mbedtls_net_recv(ssl_client, data, length);
+  }
+
+  // log_v( "%d bytes NET read of %d", ret, length);   //for low level debug
+  return ret;
+}
+
+int send_net_data(sslclient_context *ssl_client, const uint8_t *data, size_t len) {
+  int ret = mbedtls_net_send(ssl_client, data, len);
+  // log_v("Net sending %d btes->ret %d", len, ret); //for low level debug
+  return ret;
+}
+
+int get_ssl_receive(sslclient_context *ssl_client, uint8_t *data, int length) {
+  int ret = mbedtls_ssl_read(&ssl_client->ssl_ctx, data, length);
+  // log_v( "%d bytes SSL read", ret);   //for low level debug
+  return ret;
+}
+
+static bool parseHexNibble(char pb, uint8_t *res) {
+  if (pb >= '0' && pb <= '9') {
+    *res = (uint8_t)(pb - '0');
+    return true;
+  } else if (pb >= 'a' && pb <= 'f') {
+    *res = (uint8_t)(pb - 'a' + 10);
+    return true;
+  } else if (pb >= 'A' && pb <= 'F') {
+    *res = (uint8_t)(pb - 'A' + 10);
+    return true;
+  }
+  return false;
+}
+
+// Compare a name from certificate and domain name, return true if they match
+static bool matchName(const std::string &name, const std::string &domainName) {
+  size_t wildcardPos = name.find('*');
+  if (wildcardPos == std::string::npos) {
+    // Not a wildcard, expect an exact match
+    return name == domainName;
+  }
+
+  size_t firstDotPos = name.find('.');
+  if (wildcardPos > firstDotPos) {
+    // Wildcard is not part of leftmost component of domain name
+    // Do not attempt to match (rfc6125 6.4.3.1)
+    return false;
+  }
+  if (wildcardPos != 0 || firstDotPos != 1) {
+    // Matching of wildcards such as baz*.example.com and b*z.example.com
+    // is optional. Maybe implement this in the future?
+    return false;
+  }
+  size_t domainNameFirstDotPos = domainName.find('.');
+  if (domainNameFirstDotPos == std::string::npos) {
+    return false;
+  }
+  return domainName.substr(domainNameFirstDotPos) == name.substr(firstDotPos);
+}
+
+// Verifies certificate provided by the peer to match specified SHA256 fingerprint
+bool verify_ssl_fingerprint(sslclient_context *ssl_client, const char *fp, const char *domain_name) {
+  // Convert hex string to byte array
+  uint8_t fingerprint_local[32];
+  int len = strlen(fp);
+  int pos = 0;
+  for (size_t i = 0; i < sizeof(fingerprint_local); ++i) {
+    while (pos < len && ((fp[pos] == ' ') || (fp[pos] == ':'))) {
+      ++pos;
+    }
+    if (pos > len - 2) {
+      log_d("pos:%d len:%d fingerprint too short", pos, len);
+      return false;
+    }
+    uint8_t high, low;
+    if (!parseHexNibble(fp[pos], &high) || !parseHexNibble(fp[pos + 1], &low)) {
+      log_d("pos:%d len:%d invalid hex sequence: %c%c", pos, len, fp[pos], fp[pos + 1]);
+      return false;
+    }
+    pos += 2;
+    fingerprint_local[i] = low | (high << 4);
+  }
+
+  // Calculate certificate's SHA256 fingerprint
+  uint8_t fingerprint_remote[32];
+  if (!get_peer_fingerprint(ssl_client, fingerprint_remote)) {
+    return false;
+  }
+
+  // Check if fingerprints match
+  if (memcmp(fingerprint_local, fingerprint_remote, 32)) {
+    log_d("fingerprint doesn't match");
+    return false;
+  }
+
+  // Additionally check if certificate has domain name if provided
+  if (domain_name) {
+    return verify_ssl_dn(ssl_client, domain_name);
+  } else {
+    return true;
+  }
+}
+
+bool get_peer_fingerprint(sslclient_context *ssl_client, uint8_t sha256[32]) {
+  if (!ssl_client) {
+    log_d("Invalid ssl_client pointer");
+    return false;
+  };
+
+  const mbedtls_x509_crt *crt = mbedtls_ssl_get_peer_cert(&ssl_client->ssl_ctx);
+  if (!crt) {
+    log_d("Failed to get peer cert.");
+    return false;
+  };
+
+  mbedtls_sha256_context sha256_ctx;
+  mbedtls_sha256_init(&sha256_ctx);
+  mbedtls_sha256_starts(&sha256_ctx, false);
+  mbedtls_sha256_update(&sha256_ctx, crt->raw.p, crt->raw.len);
+  mbedtls_sha256_finish(&sha256_ctx, sha256);
+
+  return true;
+}
+
+// Checks if peer certificate has specified domain in CN or SANs
+bool verify_ssl_dn(sslclient_context *ssl_client, const char *domain_name) {
+  log_d("domain name: '%s'", (domain_name) ? domain_name : "(null)");
+  std::string domain_name_str(domain_name);
+  std::transform(domain_name_str.begin(), domain_name_str.end(), domain_name_str.begin(), ::tolower);
+
+  // Get certificate provided by the peer
+  const mbedtls_x509_crt *crt = mbedtls_ssl_get_peer_cert(&ssl_client->ssl_ctx);
+
+  // Check for domain name in SANs
+  const mbedtls_x509_sequence *san = &crt->subject_alt_names;
+  while (san != nullptr) {
+    std::string san_str((const char *)san->buf.p, san->buf.len);
+    std::transform(san_str.begin(), san_str.end(), san_str.begin(), ::tolower);
+
+    if (matchName(san_str, domain_name_str)) {
+      return true;
+    }
+
+    log_d("SAN '%s': no match", san_str.c_str());
+
+    // Fetch next SAN
+    san = san->next;
+  }
+
+  // Check for domain name in CN
+  const mbedtls_asn1_named_data *common_name = &crt->subject;
+  while (common_name != nullptr) {
+    // While iterating through DN objects, check for CN object
+    if (!MBEDTLS_OID_CMP(MBEDTLS_OID_AT_CN, &common_name->oid)) {
+      std::string common_name_str((const char *)common_name->val.p, common_name->val.len);
+
+      if (matchName(common_name_str, domain_name_str)) {
+        return true;
+      }
+
+      log_d("CN '%s': not match", common_name_str.c_str());
+    }
+
+    // Fetch next DN object
+    common_name = common_name->next;
+  }
+
+  return false;
+}
+#endif

lib/NetworkClientSecure/src/ssl_client.h

@@ -0,0 +1,56 @@
+/* Provide SSL/TLS functions to ESP32 with Arduino IDE
+ * by Evandro Copercini - 2017 - Apache 2.0 License
+ */
+
+#ifndef ARD_SSL_H
+#define ARD_SSL_H
+#include "mbedtls/platform.h"
+#include "mbedtls/net_sockets.h"
+#include "mbedtls/debug.h"
+#include "mbedtls/ssl.h"
+#include "mbedtls/entropy.h"
+#include "mbedtls/ctr_drbg.h"
+#include "mbedtls/error.h"
+
+typedef esp_err_t (*crt_bundle_attach_cb)(void *conf);
+
+typedef struct sslclient_context {
+  int socket;
+  mbedtls_ssl_context ssl_ctx;
+  mbedtls_ssl_config ssl_conf;
+
+  mbedtls_ctr_drbg_context drbg_ctx;
+  mbedtls_entropy_context entropy_ctx;
+
+  mbedtls_x509_crt ca_cert;
+  mbedtls_x509_crt client_cert;
+  mbedtls_pk_context client_key;
+
+  crt_bundle_attach_cb bundle_attach_cb;
+
+  unsigned long socket_timeout;
+  unsigned long handshake_timeout;
+
+  int last_error;
+  int peek_buf;
+
+} sslclient_context;
+
+void ssl_init(sslclient_context *ssl_client);
+int start_ssl_client(
+  sslclient_context *ssl_client, const IPAddress &ip, uint32_t port, const char *hostname, int timeout, const char *rootCABuff, bool useRootCABundle,
+  const char *cli_cert, const char *cli_key, const char *pskIdent, const char *psKey, bool insecure, const char **alpn_protos
+);
+void attach_ssl_certificate_bundle(sslclient_context *ssl_client, bool att);
+int ssl_starttls_handshake(sslclient_context *ssl_client);
+void stop_ssl_socket(sslclient_context *ssl_client);
+int data_to_read(sslclient_context *ssl_client);
+int send_ssl_data(sslclient_context *ssl_client, const uint8_t *data, size_t len);
+int get_ssl_receive(sslclient_context *ssl_client, uint8_t *data, int length);
+int send_net_data(sslclient_context *ssl_client, const uint8_t *data, size_t len);
+int get_net_receive(sslclient_context *ssl_client, uint8_t *data, int length);
+int peek_net_receive(sslclient_context *ssl_client, int timeout);
+bool verify_ssl_fingerprint(sslclient_context *ssl_client, const char *fp, const char *domain_name);
+bool verify_ssl_dn(sslclient_context *ssl_client, const char *domain_name);
+bool get_peer_fingerprint(sslclient_context *ssl_client, uint8_t sha256[32]);
+#endif

lib/NimBLE-Arduino/README.md

@@ -1,72 +0,0 @@
-[Latest release ![Release Version](https://img.shields.io/github/release/h2zero/NimBLE-Arduino.svg?style=plastic)
-![Release Date](https://img.shields.io/github/release-date/h2zero/NimBLE-Arduino.svg?style=plastic)](https://github.com/h2zero/NimBLE-Arduino/releases/latest/)
-
-Need help? Have questions or suggestions? Join the [![Gitter](https://badges.gitter.im/NimBLE-Arduino/community.svg)](https://gitter.im/NimBLE-Arduino/community?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge)
-<br/>
-
-# NimBLE-Arduino
-A fork of the NimBLE stack refactored for compilation in the Ardruino IDE.
-
-**As of release 1.4.0 Nordic Semiconductor nRF51 and nRF52 series devices are now supported**
-
-## Supported MCU's
- - Espressif: ESP32, ESP32C3, ESP32S3
- - Nordic: nRF51, nRF52 series (**Requires** using [n-able arduino core](https://github.com/h2zero/n-able-Arduino))
-
-**Note for ESP-IDF users: This repo will not compile correctly in ESP-IDF. An ESP-IDF component version of this library can be [found here.](https://github.com/h2zero/esp-nimble-cpp)**
-
-This library **significantly** reduces resource usage and improves performance for ESP32 BLE applications as compared with the bluedroid based library. The goal is to maintain, as much as reasonable, compatibility with the original library but refactored to use the NimBLE stack. In addition, this library will be more actively developed and maintained to provide improved capabilities and stability over the original.
-<br/>
-
-For Nordic devices, this library provides access to a completely open source and configurable BLE stack. No softdevice to work around, allowing for full debugging and resource management, continuous updates, with a cross platform API.
-
-# Arduino installation
-**Arduino Library manager:** Go to `sketch` -> `Include Library` -> `Manage Libraries`, search for NimBLE and install.
-
-**Alternatively:** Download as .zip and extract to Arduino/libraries folder, or in Arduino IDE from Sketch menu -> Include library -> Add .Zip library.
-
-`#include "NimBLEDevice.h"` at the beginning of your sketch.
-
-# Platformio installation
-* Open platformio.ini, a project configuration file located in the root of PlatformIO project.  
-* Add the following line to the lib_deps option of [env:] section:
-```
-h2zero/NimBLE-Arduino@^1.4.0
-```
-* Build a project, PlatformIO will automatically install dependencies.
-
-# Using
-This library is intended to be compatible with the original ESP32 BLE functions and types with minor changes.
-
-If you have not used the original Bluedroid library please refer to the [New user guide](docs/New_user_guide.md).
-
-If you are familiar with the original library, see: [The migration guide](docs/Migration_guide.md) for details about breaking changes and migration.
-
-Also see [Improvements_and_updates](docs/Improvements_and_updates.md) for information about non-breaking changes.
-
-[Full API documentation and class list can be found here.](https://h2zero.github.io/NimBLE-Arduino/)
-
-For added performance and optimizations see [Usage tips](docs/Usage_tips.md).
-
-Check the Refactored_original_examples in the examples folder for highlights of the differences with the original library.
-
-More advanced examples highlighting many available features are in examples/ NimBLE_Server, NimBLE_Client.
-
-Beacon examples provided by @beegee-tokyo are in examples/ BLE_Beacon_Scanner, BLE_EddystoneTLM_Beacon, BLE_EddystoneURL_Beacon.
-
-Change the settings in the `src/nimconfig.h` file to customize NimBLE to your project,
-such as increasing max connections, default is 3, absolute maximum connections is 9.
-<br/>
-
-# Development Status
-This Library is tracking the esp-nimble repo, nimble-1.4.0-idf branch, currently [@3df0d20.](https://github.com/espressif/esp-nimble)
-
-Also tracking the NimBLE related changes in ESP-IDF, master branch, currently [@95db4bb.](https://github.com/espressif/esp-idf/tree/master/components/bt/host/nimble)
-<br/>
-
-# Acknowledgments
-* [nkolban](https://github.com/nkolban) and [chegewara](https://github.com/chegewara) for the [original esp32 BLE library](https://github.com/nkolban/esp32-snippets/tree/master/cpp_utils) this project was derived from.
-* [beegee-tokyo](https://github.com/beegee-tokyo) for contributing your time to test/debug and contributing the beacon examples.
-* [Jeroen88](https://github.com/Jeroen88) for the amazing help debugging and improving the client code.
-<br/>
-

lib/NimBLE-Arduino/docs/Command_line_config.md

@@ -1,180 +0,0 @@
-# Arduino command line and platformio config options  
-
-`CONFIG_BT_NIMBLE_MAX_CONNECTIONS`  
-
-Sets the number of simultaneous connections (esp controller max is 9)  
-- Default value is 3  
-<br/>
-
-`CONFIG_NIMBLE_CPP_ATT_VALUE_TIMESTAMP_ENABLED`
-
-Enable/disable storing the timestamp when an attribute value is updated  
-This allows for checking the last update time using getTimeStamp() or getValue(time_t*)  
-If disabled, the timestamp returned from these functions will be 0.  
-Disabling timestamps will reduce the memory used for each value.  
-1 = Enabled, 0 = Disabled; Default = Disabled  
-<br/>
-
-`CONFIG_NIMBLE_CPP_ATT_VALUE_INIT_LENGTH`
-
-Set the default allocation size (bytes) for each attribute.  
-If not specified when the constructor is called. This is also the size used when a remote  
-characteristic or descriptor is constructed before a value is read/notifed.  
-Increasing this will reduce reallocations but increase memory footprint.  
-Default value is 20. Range: 1 : 512 (BLE_ATT_ATTR_MAX_LEN)  
- <br/>
- 
-`CONFIG_BT_NIMBLE_ATT_PREFERRED_MTU`  
-
-Sets the default MTU size.  
-- Default value is 255  
-<br/>
-
-`CONFIG_BT_NIMBLE_SVC_GAP_DEVICE_NAME`  
-
-Set the default device name  
-- Default value is "nimble"  
-<br/>
-
-`CONFIG_BT_NIMBLE_DEBUG`   
-
-If defined, enables debug log messages from the NimBLE host  
-- Uses approx. 32kB of flash memory.  
-<br/>
-
-`CONFIG_NIMBLE_CPP_LOG_LEVEL`   
-
-Define to set the debug log message level from the NimBLE CPP Wrapper.  
-If not defined it will use the same value as the Arduino core debug level.  
-Values: 0 = NONE, 1 = ERROR, 2 = WARNING, 3 = INFO, 4+ = DEBUG  
-<br/>
-
-`CONFIG_NIMBLE_CPP_ENABLE_RETURN_CODE_TEXT`  
-
-If defined, NimBLE host return codes will be printed as text in debug log messages.  
-- Uses approx. 7kB of flash memory.  
-<br/>
-
-`CONFIG_NIMBLE_CPP_ENABLE_GAP_EVENT_CODE_TEXT`  
-
-If defined, GAP event codes will be printed as text in debug log messages.  
-- Uses approx. 1kB of flash memory.  
-<br/>
-
-`CONFIG_NIMBLE_CPP_ENABLE_ADVERTISMENT_TYPE_TEXT`  
-
-If defined, advertisment types will be printed as text while scanning in debug log messages.  
-- Uses approx. 250 bytes of flash memory.  
-<br/>
-
-`CONFIG_BT_NIMBLE_SVC_GAP_APPEARANCE`  
-
-Set the default appearance.  
-- Default value is 0x00  
-<br/>
-
-`CONFIG_BT_NIMBLE_ROLE_CENTRAL_DISABLED`  
- 
-If defined, NimBLE Client functions will not be included.  
-- Reduces flash size by approx. 7kB.  
-<br/>
-
-`CONFIG_BT_NIMBLE_ROLE_OBSERVER_DISABLED`  
-
-If defined, NimBLE Scan functions will not be included.  
-- Reduces flash size by approx. 26kB.  
-<br/>
-
-`CONFIG_BT_NIMBLE_ROLE_PERIPHERAL_DISABLED`  
-
-If defined NimBLE Server functions will not be included.  
-- Reduces flash size by approx. 16kB.  
-<br/>
-
-`CONFIG_BT_NIMBLE_ROLE_BROADCASTER_DISABLED`  
-
-If defined, NimBLE Advertising functions will not be included.  
-- Reduces flash size by approx. 5kB.  
-<br/>
-
-`CONFIG_BT_NIMBLE_MAX_BONDS`  
-
-Sets the number of devices allowed to store/bond with  
-- Default value is 3  
-<br/>
-
-`CONFIG_BT_NIMBLE_MAX_CCCDS`  
-
-Sets the maximum number of CCCD subscriptions to store  
-- Default value is 8  
-<br/>
-
-`CONFIG_BT_NIMBLE_RPA_TIMEOUT`  
-
-Sets the random address refresh time in seconds.  
-- Default value is 900  
-<br/>
-
-`CONFIG_BT_NIMBLE_MSYS1_BLOCK_COUNT`  
-
-Set the number of msys blocks For prepare write & prepare responses. This may need to be increased if  
-you are sending large blocks of data with a low MTU. E.g: 512 bytes with 23 MTU will fail.  
-- Default value is 12  
-<br/>
-
-`CONFIG_BT_NIMBLE_MEM_ALLOC_MODE_EXTERNAL`  
-
-Sets the NimBLE stack to use external PSRAM will be loaded  
-- Must be defined with a value of 1; Default is CONFIG_BT_NIMBLE_MEM_ALLOC_MODE_INTERNAL 1  
-<br/>
-
-`CONFIG_BT_NIMBLE_PINNED_TO_CORE`  
-
-Sets the core the NimBLE host stack will run on   
-- Options: 0 or 1
-<br/>
-
-`CONFIG_BT_NIMBLE_TASK_STACK_SIZE`  
-
-Set the task stack size for the NimBLE core.  
-- Default is 4096  
-<br/>
-
-`CONFIG_NIMBLE_STACK_USE_MEM_POOLS`
-
- Enable the use of memory pools for stack operations. This will use slightly more RAM but may provide more stability.
- 
-- Options: 0 or 1, default is disabled (0)  
-<br/>
-
-### Extended advertising settings, For use with ESP32C3, ESP32S3, ESP32H2 ONLY!
- 
-`CONFIG_BT_NIMBLE_EXT_ADV`
-
-Set to 1 to enable extended advertising features.
-<br/>
-
-`CONFIG_BT_NIMBLE_MAX_EXT_ADV_INSTANCES`
-
-Sets the max number of extended advertising instances 
-- Range: 0 - 4
-- Default is 1
-<br/>
-
-`CONFIG_BT_NIMBLE_MAX_EXT_ADV_DATA_LEN`
-
-Set the max extended advertising data size,
-- Range: 31 - 1650
-- Default is 255
-<br/>
-
-`CONFIG_BT_NIMBLE_ENABLE_PERIODIC_ADV`
-
-Set to 1 to enable periodic advertising.
-<br/>
-
-`CONFIG_BT_NIMBLE_MAX_PERIODIC_SYNCS`
-
-Set the maximum number of periodically synced devices.
-- Range: 1 - 8
-- Default is 1

lib/NimBLE-Arduino/docs/index.md

@@ -1,70 +0,0 @@
-# Overview
-
-This is a C++ BLE library for Espressif ESP32 and Nordic nRF51/nRF52 devices that uses the NimBLE BLE stack.  
-The aim is to maintain, as much as reasonable, the original ESP32 Arduino BLE API by while adding new features and making improvements in performance, resource use, and stability.  
-<br/>
-
-# What is NimBLE?
-NimBLE is a completely open source Bluetooth Low Energy stack produced by [Apache](https://github.com/apache/mynewt-nimble).  
-<br/>
-
-# Arduino installation
-**NOTE:** Nordic devices require using [n-able arduino core](https://github.com/h2zero/n-able-Arduino)
-
-**Arduino Library manager:** Go to `sketch` -> `Include Library` -> `Manage Libraries` and search for NimBLE and install.
-
-**Alternatively:** Download as .zip and extract to Arduino/libraries folder, or in Arduino IDE from Sketch menu -> Include library -> Add .Zip library.
-
-`#include "NimBLEDevice.h"` at the beginning of your sketch.
-
-Call `NimBLEDevice::init` in `setup`.  
-<br/>
-
-# Platformio installation
-* Open platformio.ini, a project configuration file located in the root of PlatformIO project.  
-* Add the following line to the lib_deps option of [env:] section:
-```
-h2zero/NimBLE-Arduino@^1.4.0
-```
-* Build a project, PlatformIO will automatically install dependencies.  
-<br/>
-
-# Using
-This library is intended to be compatible with the original ESP32 BLE library functions and types with minor changes.
-
-If you have not used the original BLE library please refer to the [New user guide](New_user_guide.md).
-
-If you are familiar with the original library, see: [The migration guide](Migration_guide.md) for details.
-
-Also see [Improvements and updates](Improvements_and_updates.md) for information about non-breaking changes.
-
-For more advanced usage see [Usage tips](Usage_tips.md) for more performance and optimization.  
-<br/>
-
-## Examples
-See the Refactored_original_examples in the examples folder for highlights of the differences with the original library.
-
-More advanced examples highlighting many available features are in examples/NimBLE_Server, NimBLE_Client.
-
-Beacon examples provided by [beegee-tokyo](https://github.com/beegee-tokyo) are in examples/BLE_Beacon_Scanner, BLE_EddystoneTLM_Beacon, BLE_EddystoneURL_Beacon.
-
-Change the settings in the nimconfig.h file to customize NimBLE to your project, such as increasing max connections (default is 3).  
-<br/>
-
-## Arduino command line and platformio
-As an alternative to changing the configuration in nimconfig.h, Arduino command line and platformio.ini options are available.
-
-See the command line configuration options available in [Command line config](Command_line_config.md).  
-<br/>
-
-# Need help? Have a question or suggestion?
-Come chat on [gitter](https://gitter.im/NimBLE-Arduino/community?utm_source=share-link&utm_medium=link&utm_campaign=share-link) or open an issue at [NimBLE-Arduino](https://github.com/h2zero/NimBLE-Arduino/issues) or [esp-nimble-cpp](https://github.com/h2zero/esp-nimble-cpp/issues)  
-<br/>
-
-# Acknowledgments
-
-* [nkolban](https://github.com/nkolban) and [chegewara](https://github.com/chegewara) for the [original esp32 BLE library](https://github.com/nkolban/esp32-snippets/tree/master/cpp_utils) this project was derived from.
-* [beegee-tokyo](https://github.com/beegee-tokyo) for contributing your time to test/debug and contributing the beacon examples.
-* [Jeroen88](https://github.com/Jeroen88) for the amazing help debugging and improving the client code.  
-<br/>
-

lib/NimBLE-Arduino/examples/BLE_Beacon_Scanner/BLE_Beacon_Scanner.ino

@@ -1,153 +0,0 @@
-/*
-   Based on Neil Kolban example for IDF: https://github.com/nkolban/esp32-snippets/blob/master/cpp_utils/tests/BLE%20Tests/SampleScan.cpp
-   Ported to Arduino ESP32 by Evandro Copercini
-*/
-
-/** NimBLE differences highlighted in comment blocks **/
-
-/*******original********
-  #include <BLEDevice.h>
-  #include <BLEUtils.h>
-  #include <BLEScan.h>
-  #include <BLEAdvertisedDevice.h>
-  #include "BLEEddystoneURL.h"
-  #include "BLEEddystoneTLM.h"
-  #include "BLEBeacon.h"
-***********************/
-
-#include <Arduino.h>
-
-#include <NimBLEDevice.h>
-#include <NimBLEAdvertisedDevice.h>
-#include "NimBLEEddystoneURL.h"
-#include "NimBLEEddystoneTLM.h"
-#include "NimBLEBeacon.h"
-
-#define ENDIAN_CHANGE_U16(x) ((((x)&0xFF00) >> 8) + (((x)&0xFF) << 8))
-
-int scanTime = 5; //In seconds
-BLEScan *pBLEScan;
-
-class MyAdvertisedDeviceCallbacks : public BLEAdvertisedDeviceCallbacks
-{
-    /*** Only a reference to the advertised device is passed now
-      void onResult(BLEAdvertisedDevice advertisedDevice) { **/
-    void onResult(BLEAdvertisedDevice *advertisedDevice)
-    {
-      if (advertisedDevice->haveName())
-      {
-        Serial.print("Device name: ");
-        Serial.println(advertisedDevice->getName().c_str());
-        Serial.println("");
-      }
-
-      if (advertisedDevice->haveServiceUUID())
-      {
-        BLEUUID devUUID = advertisedDevice->getServiceUUID();
-        Serial.print("Found ServiceUUID: ");
-        Serial.println(devUUID.toString().c_str());
-        Serial.println("");
-      }
-      else
-      {
-        if (advertisedDevice->haveManufacturerData() == true)
-        {
-          std::string strManufacturerData = advertisedDevice->getManufacturerData();
-
-          uint8_t cManufacturerData[100];
-          strManufacturerData.copy((char *)cManufacturerData, strManufacturerData.length(), 0);
-
-          if (strManufacturerData.length() == 25 && cManufacturerData[0] == 0x4C && cManufacturerData[1] == 0x00)
-          {
-            Serial.println("Found an iBeacon!");
-            BLEBeacon oBeacon = BLEBeacon();
-            oBeacon.setData(strManufacturerData);
-            Serial.printf("iBeacon Frame\n");
-            Serial.printf("ID: %04X Major: %d Minor: %d UUID: %s Power: %d\n", oBeacon.getManufacturerId(), ENDIAN_CHANGE_U16(oBeacon.getMajor()), ENDIAN_CHANGE_U16(oBeacon.getMinor()), oBeacon.getProximityUUID().toString().c_str(), oBeacon.getSignalPower());
-          }
-          else
-          {
-            Serial.println("Found another manufacturers beacon!");
-            Serial.printf("strManufacturerData: %d ", strManufacturerData.length());
-            for (int i = 0; i < strManufacturerData.length(); i++)
-            {
-              Serial.printf("[%X]", cManufacturerData[i]);
-            }
-            Serial.printf("\n");
-          }
-        }
-        return;
-      }
-
-      BLEUUID eddyUUID = (uint16_t)0xfeaa;
-
-      if (advertisedDevice->getServiceUUID().equals(eddyUUID))
-      {
-        std::string serviceData = advertisedDevice->getServiceData(eddyUUID);
-        if (serviceData[0] == 0x10)
-        {
-          Serial.println("Found an EddystoneURL beacon!");
-          BLEEddystoneURL foundEddyURL = BLEEddystoneURL();
-
-          foundEddyURL.setData(serviceData);
-          std::string bareURL = foundEddyURL.getURL();
-          if (bareURL[0] == 0x00)
-          {
-            Serial.println("DATA-->");
-            for (int idx = 0; idx < serviceData.length(); idx++)
-            {
-              Serial.printf("0x%08X ", serviceData[idx]);
-            }
-            Serial.println("\nInvalid Data");
-            return;
-          }
-
-          Serial.printf("Found URL: %s\n", foundEddyURL.getURL().c_str());
-          Serial.printf("Decoded URL: %s\n", foundEddyURL.getDecodedURL().c_str());
-          Serial.printf("TX power %d\n", foundEddyURL.getPower());
-          Serial.println("\n");
-        }
-        else if (serviceData[0] == 0x20)
-        {
-          Serial.println("Found an EddystoneTLM beacon!");
-          BLEEddystoneTLM foundEddyURL = BLEEddystoneTLM();
-          foundEddyURL.setData(serviceData);
-
-          Serial.printf("Reported battery voltage: %dmV\n", foundEddyURL.getVolt());
-          Serial.printf("Reported temperature from TLM class: %.2fC\n", (double)foundEddyURL.getTemp());
-          int temp = (int)serviceData[5] + (int)(serviceData[4] << 8);
-          float calcTemp = temp / 256.0f;
-          Serial.printf("Reported temperature from data: %.2fC\n", calcTemp);
-          Serial.printf("Reported advertise count: %d\n", foundEddyURL.getCount());
-          Serial.printf("Reported time since last reboot: %ds\n", foundEddyURL.getTime());
-          Serial.println("\n");
-          Serial.print(foundEddyURL.toString().c_str());
-          Serial.println("\n");
-        }
-      }
-    }
-};
-
-void setup()
-{
-  Serial.begin(115200);
-  Serial.println("Scanning...");
-
-  BLEDevice::init("");
-  pBLEScan = BLEDevice::getScan(); //create new scan
-  pBLEScan->setAdvertisedDeviceCallbacks(new MyAdvertisedDeviceCallbacks());
-  pBLEScan->setActiveScan(true); //active scan uses more power, but get results faster
-  pBLEScan->setInterval(100);
-  pBLEScan->setWindow(99); // less or equal setInterval value
-}
-
-void loop()
-{
-  // put your main code here, to run repeatedly:
-  BLEScanResults foundDevices = pBLEScan->start(scanTime, false);
-  Serial.print("Devices found: ");
-  Serial.println(foundDevices.getCount());
-  Serial.println("Scan done!");
-  pBLEScan->clearResults(); // delete results fromBLEScan buffer to release memory
-  delay(2000);
-}

lib/NimBLE-Arduino/examples/BLE_Beacon_Scanner/BLE_Beacon_Scanner.md

@@ -1,9 +0,0 @@
-## BLE Beacon Scanner
-
-Initiates a BLE device scan.
-Checks if the discovered devices are 
-- an iBeacon
-- an Eddystone TLM beacon
-- an Eddystone URL beacon
-
-and sends the decoded beacon information over Serial log

lib/NimBLE-Arduino/examples/BLE_EddystoneTLM_Beacon/BLE_EddystoneTLM_Beacon.ino

@@ -1,113 +0,0 @@
-/*
-   EddystoneTLM beacon for NimBLE by BeeGee based on https://github.com/pcbreflux/espressif/blob/master/esp32/arduino/sketchbook/ESP32_Eddystone_TLM_deepsleep/ESP32_Eddystone_TLM_deepsleep.ino
-   EddystoneTLM frame specification https://github.com/google/eddystone/blob/master/eddystone-tlm/tlm-plain.md
-*/
-
-/*
-   Create a BLE server that will send periodic Eddystone URL frames.
-   The design of creating the BLE server is:
-   1. Create a BLE Server
-   2. Create advertising data
-   3. Start advertising.
-   4. wait
-   5. Stop advertising.
-   6. deep sleep
-   
-*/
-
-#include "NimBLEDevice.h"
-#include "NimBLEBeacon.h"
-#include "NimBLEAdvertising.h"
-#include "NimBLEEddystoneURL.h"
-
-#include "sys/time.h"
-#include "esp_sleep.h"
-
-#define GPIO_DEEP_SLEEP_DURATION 10     // sleep x seconds and then wake up
-
-// UUID 1 128-Bit (may use linux tool uuidgen or random numbers via https://www.uuidgenerator.net/)
-#define BEACON_UUID "8ec76ea3-6668-48da-9866-75be8bc86f4d" 
-
-RTC_DATA_ATTR static time_t last;    // remember last boot in RTC Memory
-RTC_DATA_ATTR static uint32_t bootcount; // remember number of boots in RTC Memory
-
-BLEAdvertising *pAdvertising;
-struct timeval nowTimeStruct;
-
-time_t lastTenth;
-
-// Check
-// https://github.com/google/eddystone/blob/master/eddystone-tlm/tlm-plain.md
-// and http://www.hugi.scene.org/online/coding/hugi%2015%20-%20cmtadfix.htm
-// for the temperature value. It is a 8.8 fixed-point notation
-void setBeacon()
-{
-  char beacon_data[25];
-  uint16_t beconUUID = 0xFEAA;
-  uint16_t volt = random(2800, 3700); // 3300mV = 3.3V
-  float tempFloat = random(2000, 3100) / 100.0f;
-  Serial.printf("Random temperature is %.2fC\n", tempFloat);
-  int temp = (int)(tempFloat * 256); //(uint16_t)((float)23.00);
-  Serial.printf("Converted to 8.8 format %0X%0X\n", (temp >> 8), (temp & 0xFF));
-
-  BLEAdvertisementData oAdvertisementData = BLEAdvertisementData();
-  BLEAdvertisementData oScanResponseData = BLEAdvertisementData();
-
-  oScanResponseData.setFlags(0x06); // GENERAL_DISC_MODE 0x02 | BR_EDR_NOT_SUPPORTED 0x04
-  oScanResponseData.setCompleteServices(BLEUUID(beconUUID));
-
-  beacon_data[0] = 0x20;                // Eddystone Frame Type (Unencrypted Eddystone-TLM)
-  beacon_data[1] = 0x00;                // TLM version
-  beacon_data[2] = (volt >> 8);           // Battery voltage, 1 mV/bit i.e. 0xCE4 = 3300mV = 3.3V
-  beacon_data[3] = (volt & 0xFF);           //
-  beacon_data[4] = (temp >> 8);           // Beacon temperature
-  beacon_data[5] = (temp & 0xFF);           //
-  beacon_data[6] = ((bootcount & 0xFF000000) >> 24);  // Advertising PDU count
-  beacon_data[7] = ((bootcount & 0xFF0000) >> 16);  //
-  beacon_data[8] = ((bootcount & 0xFF00) >> 8);   //
-  beacon_data[9] = (bootcount & 0xFF);        //
-  beacon_data[10] = ((lastTenth & 0xFF000000) >> 24); // Time since power-on or reboot as 0.1 second resolution counter
-  beacon_data[11] = ((lastTenth & 0xFF0000) >> 16);   //
-  beacon_data[12] = ((lastTenth & 0xFF00) >> 8);    //
-  beacon_data[13] = (lastTenth & 0xFF);       //
-
-  oScanResponseData.setServiceData(BLEUUID(beconUUID), std::string(beacon_data, 14));
-  oAdvertisementData.setName("TLMBeacon");
-  pAdvertising->setAdvertisementData(oAdvertisementData);
-  pAdvertising->setScanResponseData(oScanResponseData);
-}
-
-void setup()
-{
-
-  Serial.begin(115200);
-  gettimeofday(&nowTimeStruct, NULL);
-
-  Serial.printf("start ESP32 %d\n", bootcount++);
-
-  Serial.printf("deep sleep (%lds since last reset, %lds since last boot)\n", nowTimeStruct.tv_sec, nowTimeStruct.tv_sec - last);
-
-  last = nowTimeStruct.tv_sec;
-  lastTenth = nowTimeStruct.tv_sec * 10; // Time since last reset as 0.1 second resolution counter
-
-  // Create the BLE Device
-  BLEDevice::init("TLMBeacon");
-
-  BLEDevice::setPower(ESP_PWR_LVL_N12);
-
-  pAdvertising = BLEDevice::getAdvertising();
-
-  setBeacon();
-  // Start advertising
-  pAdvertising->start();
-  Serial.println("Advertizing started for 10s ...");
-  delay(10000);
-  pAdvertising->stop();
-  Serial.printf("enter deep sleep for 10s\n");
-  esp_deep_sleep(1000000LL * GPIO_DEEP_SLEEP_DURATION);
-  Serial.printf("in deep sleep\n");
-}
-
-void loop()
-{
-}

lib/NimBLE-Arduino/examples/BLE_EddystoneTLM_Beacon/BLE_EddystoneTLM_Beacon.md

@@ -1,14 +0,0 @@
-## Eddystone TLM beacon
-EddystoneTLM beacon by BeeGee based on
-[pcbreflux ESP32 Eddystone TLM deepsleep](https://github.com/pcbreflux/espressif/blob/master/esp32/arduino/sketchbook/ESP32_Eddystone_TLM_deepsleep/ESP32_Eddystone_TLM_deepsleep.ino)
-
-[EddystoneTLM frame specification](https://github.com/google/eddystone/blob/master/eddystone-tlm/tlm-plain.md)
-
-   Create a BLE server that will send periodic Eddystone TLM frames.
-   The design of creating the BLE server is:
-   1. Create a BLE Server
-   2. Create advertising data
-   3. Start advertising.
-   4. wait
-   5. Stop advertising.
-   6. deep sleep

lib/NimBLE-Arduino/examples/BLE_EddystoneURL_Beacon/BLE_EddystoneURL_Beacon.ino

@@ -1,185 +0,0 @@
-/*
-   EddystoneURL beacon for NimBLE by BeeGee
-   EddystoneURL frame specification https://github.com/google/eddystone/blob/master/eddystone-url/README.md
-
-*/
-
-/*
-   Create a BLE server that will send periodic Eddystone URL frames.
-   The design of creating the BLE server is:
-   1. Create a BLE Server
-   2. Create advertising data
-   3. Start advertising.
-   4. wait
-   5. Stop advertising.
-   6. deep sleep
-
-*/
-
-#include "NimBLEDevice.h"
-#include "NimBLEBeacon.h"
-#include "NimBLEEddystoneURL.h"
-
-#include "sys/time.h"
-#include "esp_sleep.h"
-
-#define GPIO_DEEP_SLEEP_DURATION 10     // sleep x seconds and then wake up
-
-// UUID 1 128-Bit (may use linux tool uuidgen or random numbers via https://www.uuidgenerator.net/)
-#define BEACON_UUID "8ec76ea3-6668-48da-9866-75be8bc86f4d" 
-
-RTC_DATA_ATTR static time_t last;    // remember last boot in RTC Memory
-RTC_DATA_ATTR static uint32_t bootcount; // remember number of boots in RTC Memory
-
-BLEAdvertising *pAdvertising;
-struct timeval now;
-
-static const char *eddystone_url_prefix_subs[] = {
-  "http://www.",
-  "https://www.",
-  "http://",
-  "https://",
-  "urn:uuid:",
-  NULL
-};
-
-static const char *eddystone_url_suffix_subs[] = {
-  ".com/",
-  ".org/",
-  ".edu/",
-  ".net/",
-  ".info/",
-  ".biz/",
-  ".gov/",
-  ".com",
-  ".org",
-  ".edu",
-  ".net",
-  ".info",
-  ".biz",
-  ".gov",
-  NULL
-};
-
-static int string_begin_with(const char *str, const char *prefix)
-{
-  int prefix_len = strlen(prefix);
-  if (strncmp(prefix, str, prefix_len) == 0)
-  {
-    return prefix_len;
-  }
-  return 0;
-}
-
-void setBeacon()
-{
-  BLEAdvertisementData oAdvertisementData = BLEAdvertisementData();
-  BLEAdvertisementData oScanResponseData = BLEAdvertisementData();
-
-  const char url[] = "https://d.giesecke.tk";
-
-  int scheme_len, ext_len = 1, i, idx, url_idx;
-  char *ret_data;
-  int url_len = strlen(url);
-
-  ret_data = (char *)calloc(1, url_len + 13);
-
-  ret_data[0] = 2;   // Len
-  ret_data[1] = 0x01;  // Type Flags
-  ret_data[2] = 0x06;  // GENERAL_DISC_MODE 0x02 | BR_EDR_NOT_SUPPORTED 0x04
-  ret_data[3] = 3;   // Len
-  ret_data[4] = 0x03;  // Type 16-Bit UUID
-  ret_data[5] = 0xAA;  // Eddystone UUID 2 -> 0xFEAA LSB
-  ret_data[6] = 0xFE;  // Eddystone UUID 1 MSB
-  ret_data[7] = 19; // Length of Beacon Data
-  ret_data[8] = 0x16;  // Type Service Data
-  ret_data[9] = 0xAA;  // Eddystone UUID 2 -> 0xFEAA LSB
-  ret_data[10] = 0xFE; // Eddystone UUID 1 MSB
-  ret_data[11] = 0x10; // Eddystone Frame Type
-  ret_data[12] = 0xF4; // Beacons TX power at 0m
-
-  i = 0, idx = 13, url_idx = 0;
-
-  //replace prefix
-  scheme_len = 0;
-  while (eddystone_url_prefix_subs[i] != NULL)
-  {
-    if ((scheme_len = string_begin_with(url, eddystone_url_prefix_subs[i])) > 0)
-    {
-      ret_data[idx] = i;
-      idx++;
-      url_idx += scheme_len;
-      break;
-    }
-    i++;
-  }
-  while (url_idx < url_len)
-  {
-    i = 0;
-    ret_data[idx] = url[url_idx];
-    ext_len = 1;
-    while (eddystone_url_suffix_subs[i] != NULL)
-    {
-      if ((ext_len = string_begin_with(&url[url_idx], eddystone_url_suffix_subs[i])) > 0)
-      {
-        ret_data[idx] = i;
-        break;
-      }
-      else
-      {
-        ext_len = 1; //inc 1
-      }
-      i++;
-    }
-    url_idx += ext_len;
-    idx++;
-  }
-  ret_data[7] = idx - 8;
-
-  Serial.printf("struct size %d url size %d reported len %d\n",
-                url_len + 13,
-                url_len, ret_data[7]);
-
-  Serial.printf("URL in data %s\n", &ret_data[13]);
-
-  std::string eddyStoneData(ret_data);
-
-  oAdvertisementData.addData(eddyStoneData);
-  oScanResponseData.setName("MeBeacon");
-  pAdvertising->setAdvertisementData(oAdvertisementData);
-  pAdvertising->setScanResponseData(oScanResponseData);
-}
-
-void setup()
-{
-
-  Serial.begin(115200);
-  gettimeofday(&now, NULL);
-
-  Serial.printf("start ESP32 %d\n", bootcount++);
-
-  Serial.printf("deep sleep (%lds since last reset, %lds since last boot)\n", now.tv_sec, now.tv_sec - last);
-
-  last = now.tv_sec;
-
-  // Create the BLE Device
-  BLEDevice::init("MeBeacon");
-
-  BLEDevice::setPower(ESP_PWR_LVL_N12);
-
-  pAdvertising = BLEDevice::getAdvertising();
-
-  setBeacon();
-  // Start advertising
-  pAdvertising->start();
-  Serial.println("Advertizing started...");
-  delay(10000);
-  pAdvertising->stop();
-  Serial.printf("enter deep sleep\n");
-  esp_deep_sleep(1000000LL * GPIO_DEEP_SLEEP_DURATION);
-  Serial.printf("in deep sleep\n");
-}
-
-void loop()
-{
-}

lib/NimBLE-Arduino/examples/BLE_EddystoneURL_Beacon/BLE_EddystoneURL_Beacon.md

@@ -1,14 +0,0 @@
-## Eddystone URL beacon
-EddystoneURL beacon by BeeGee based on
-[pcbreflux ESP32 Eddystone URL deepsleep](https://github.com/pcbreflux/espressif/tree/master/esp32/arduino/sketchbook/ESP32_Eddystone_URL_deepsleep)
-
-[EddystoneURL frame specification](https://github.com/google/eddystone/blob/master/eddystone-url/README.md)
-
-   Create a BLE server that will send periodic Eddystone URL frames.
-   The design of creating the BLE server is:
-   1. Create a BLE Server
-   2. Create advertising data
-   3. Start advertising.
-   4. wait
-   5. Stop advertising.
-   6. deep sleep

lib/NimBLE-Arduino/examples/NimBLE_Client/NimBLE_Client.ino

@@ -1,396 +0,0 @@
-
-/** NimBLE_Server Demo:
- *
- *  Demonstrates many of the available features of the NimBLE client library.
- *
- *  Created: on March 24 2020
- *      Author: H2zero
- *
-*/
-
-#include <NimBLEDevice.h>
-
-void scanEndedCB(NimBLEScanResults results);
-
-static NimBLEAdvertisedDevice* advDevice;
-
-static bool doConnect = false;
-static uint32_t scanTime = 0; /** 0 = scan forever */
-
-
-/**  None of these are required as they will be handled by the library with defaults. **
- **                       Remove as you see fit for your needs                        */
-class ClientCallbacks : public NimBLEClientCallbacks {
-    void onConnect(NimBLEClient* pClient) {
-        Serial.println("Connected");
-        /** After connection we should change the parameters if we don't need fast response times.
-         *  These settings are 150ms interval, 0 latency, 450ms timout.
-         *  Timeout should be a multiple of the interval, minimum is 100ms.
-         *  I find a multiple of 3-5 * the interval works best for quick response/reconnect.
-         *  Min interval: 120 * 1.25ms = 150, Max interval: 120 * 1.25ms = 150, 0 latency, 60 * 10ms = 600ms timeout
-         */
-        pClient->updateConnParams(120,120,0,60);
-    };
-
-    void onDisconnect(NimBLEClient* pClient) {
-        Serial.print(pClient->getPeerAddress().toString().c_str());
-        Serial.println(" Disconnected - Starting scan");
-        NimBLEDevice::getScan()->start(scanTime, scanEndedCB);
-    };
-
-    /** Called when the peripheral requests a change to the connection parameters.
-     *  Return true to accept and apply them or false to reject and keep
-     *  the currently used parameters. Default will return true.
-     */
-    bool onConnParamsUpdateRequest(NimBLEClient* pClient, const ble_gap_upd_params* params) {
-        if(params->itvl_min < 24) { /** 1.25ms units */
-            return false;
-        } else if(params->itvl_max > 40) { /** 1.25ms units */
-            return false;
-        } else if(params->latency > 2) { /** Number of intervals allowed to skip */
-            return false;
-        } else if(params->supervision_timeout > 100) { /** 10ms units */
-            return false;
-        }
-
-        return true;
-    };
-
-    /********************* Security handled here **********************
-    ****** Note: these are the same return values as defaults ********/
-    uint32_t onPassKeyRequest(){
-        Serial.println("Client Passkey Request");
-        /** return the passkey to send to the server */
-        return 123456;
-    };
-
-    bool onConfirmPIN(uint32_t pass_key){
-        Serial.print("The passkey YES/NO number: ");
-        Serial.println(pass_key);
-    /** Return false if passkeys don't match. */
-        return true;
-    };
-
-    /** Pairing process complete, we can check the results in ble_gap_conn_desc */
-    void onAuthenticationComplete(ble_gap_conn_desc* desc){
-        if(!desc->sec_state.encrypted) {
-            Serial.println("Encrypt connection failed - disconnecting");
-            /** Find the client with the connection handle provided in desc */
-            NimBLEDevice::getClientByID(desc->conn_handle)->disconnect();
-            return;
-        }
-    };
-};
-
-
-/** Define a class to handle the callbacks when advertisments are received */
-class AdvertisedDeviceCallbacks: public NimBLEAdvertisedDeviceCallbacks {
-
-    void onResult(NimBLEAdvertisedDevice* advertisedDevice) {
-        Serial.print("Advertised Device found: ");
-        Serial.println(advertisedDevice->toString().c_str());
-        if(advertisedDevice->isAdvertisingService(NimBLEUUID("DEAD")))
-        {
-            Serial.println("Found Our Service");
-            /** stop scan before connecting */
-            NimBLEDevice::getScan()->stop();
-            /** Save the device reference in a global for the client to use*/
-            advDevice = advertisedDevice;
-            /** Ready to connect now */
-            doConnect = true;
-        }
-    };
-};
-
-
-/** Notification / Indication receiving handler callback */
-void notifyCB(NimBLERemoteCharacteristic* pRemoteCharacteristic, uint8_t* pData, size_t length, bool isNotify){
-    std::string str = (isNotify == true) ? "Notification" : "Indication";
-    str += " from ";
-    /** NimBLEAddress and NimBLEUUID have std::string operators */
-    str += std::string(pRemoteCharacteristic->getRemoteService()->getClient()->getPeerAddress());
-    str += ": Service = " + std::string(pRemoteCharacteristic->getRemoteService()->getUUID());
-    str += ", Characteristic = " + std::string(pRemoteCharacteristic->getUUID());
-    str += ", Value = " + std::string((char*)pData, length);
-    Serial.println(str.c_str());
-}
-
-/** Callback to process the results of the last scan or restart it */
-void scanEndedCB(NimBLEScanResults results){
-    Serial.println("Scan Ended");
-}
-
-
-/** Create a single global instance of the callback class to be used by all clients */
-static ClientCallbacks clientCB;
-
-
-/** Handles the provisioning of clients and connects / interfaces with the server */
-bool connectToServer() {
-    NimBLEClient* pClient = nullptr;
-
-    /** Check if we have a client we should reuse first **/
-    if(NimBLEDevice::getClientListSize()) {
-        /** Special case when we already know this device, we send false as the
-         *  second argument in connect() to prevent refreshing the service database.
-         *  This saves considerable time and power.
-         */
-        pClient = NimBLEDevice::getClientByPeerAddress(advDevice->getAddress());
-        if(pClient){
-            if(!pClient->connect(advDevice, false)) {
-                Serial.println("Reconnect failed");
-                return false;
-            }
-            Serial.println("Reconnected client");
-        }
-        /** We don't already have a client that knows this device,
-         *  we will check for a client that is disconnected that we can use.
-         */
-        else {
-            pClient = NimBLEDevice::getDisconnectedClient();
-        }
-    }
-
-    /** No client to reuse? Create a new one. */
-    if(!pClient) {
-        if(NimBLEDevice::getClientListSize() >= NIMBLE_MAX_CONNECTIONS) {
-            Serial.println("Max clients reached - no more connections available");
-            return false;
-        }
-
-        pClient = NimBLEDevice::createClient();
-
-        Serial.println("New client created");
-
-        pClient->setClientCallbacks(&clientCB, false);
-        /** Set initial connection parameters: These settings are 15ms interval, 0 latency, 120ms timout.
-         *  These settings are safe for 3 clients to connect reliably, can go faster if you have less
-         *  connections. Timeout should be a multiple of the interval, minimum is 100ms.
-         *  Min interval: 12 * 1.25ms = 15, Max interval: 12 * 1.25ms = 15, 0 latency, 51 * 10ms = 510ms timeout
-         */
-        pClient->setConnectionParams(12,12,0,51);
-        /** Set how long we are willing to wait for the connection to complete (seconds), default is 30. */
-        pClient->setConnectTimeout(5);
-
-
-        if (!pClient->connect(advDevice)) {
-            /** Created a client but failed to connect, don't need to keep it as it has no data */
-            NimBLEDevice::deleteClient(pClient);
-            Serial.println("Failed to connect, deleted client");
-            return false;
-        }
-    }
-
-    if(!pClient->isConnected()) {
-        if (!pClient->connect(advDevice)) {
-            Serial.println("Failed to connect");
-            return false;
-        }
-    }
-
-    Serial.print("Connected to: ");
-    Serial.println(pClient->getPeerAddress().toString().c_str());
-    Serial.print("RSSI: ");
-    Serial.println(pClient->getRssi());
-
-    /** Now we can read/write/subscribe the charateristics of the services we are interested in */
-    NimBLERemoteService* pSvc = nullptr;
-    NimBLERemoteCharacteristic* pChr = nullptr;
-    NimBLERemoteDescriptor* pDsc = nullptr;
-
-    pSvc = pClient->getService("DEAD");
-    if(pSvc) {     /** make sure it's not null */
-        pChr = pSvc->getCharacteristic("BEEF");
-
-        if(pChr) {     /** make sure it's not null */
-            if(pChr->canRead()) {
-                Serial.print(pChr->getUUID().toString().c_str());
-                Serial.print(" Value: ");
-                Serial.println(pChr->readValue().c_str());
-            }
-
-            if(pChr->canWrite()) {
-                if(pChr->writeValue("Tasty")) {
-                    Serial.print("Wrote new value to: ");
-                    Serial.println(pChr->getUUID().toString().c_str());
-                }
-                else {
-                    /** Disconnect if write failed */
-                    pClient->disconnect();
-                    return false;
-                }
-
-                if(pChr->canRead()) {
-                    Serial.print("The value of: ");
-                    Serial.print(pChr->getUUID().toString().c_str());
-                    Serial.print(" is now: ");
-                    Serial.println(pChr->readValue().c_str());
-                }
-            }
-
-            /** registerForNotify() has been deprecated and replaced with subscribe() / unsubscribe().
-             *  Subscribe parameter defaults are: notifications=true, notifyCallback=nullptr, response=false.
-             *  Unsubscribe parameter defaults are: response=false.
-             */
-            if(pChr->canNotify()) {
-                //if(!pChr->registerForNotify(notifyCB)) {
-                if(!pChr->subscribe(true, notifyCB)) {
-                    /** Disconnect if subscribe failed */
-                    pClient->disconnect();
-                    return false;
-                }
-            }
-            else if(pChr->canIndicate()) {
-                /** Send false as first argument to subscribe to indications instead of notifications */
-                //if(!pChr->registerForNotify(notifyCB, false)) {
-                if(!pChr->subscribe(false, notifyCB)) {
-                    /** Disconnect if subscribe failed */
-                    pClient->disconnect();
-                    return false;
-                }
-            }
-        }
-
-    } else {
-        Serial.println("DEAD service not found.");
-    }
-
-    pSvc = pClient->getService("BAAD");
-    if(pSvc) {     /** make sure it's not null */
-        pChr = pSvc->getCharacteristic("F00D");
-
-        if(pChr) {     /** make sure it's not null */
-            if(pChr->canRead()) {
-                Serial.print(pChr->getUUID().toString().c_str());
-                Serial.print(" Value: ");
-                Serial.println(pChr->readValue().c_str());
-            }
-
-            pDsc = pChr->getDescriptor(NimBLEUUID("C01D"));
-            if(pDsc) {   /** make sure it's not null */
-                Serial.print("Descriptor: ");
-                Serial.print(pDsc->getUUID().toString().c_str());
-                Serial.print(" Value: ");
-                Serial.println(pDsc->readValue().c_str());
-            }
-
-            if(pChr->canWrite()) {
-                if(pChr->writeValue("No tip!")) {
-                    Serial.print("Wrote new value to: ");
-                    Serial.println(pChr->getUUID().toString().c_str());
-                }
-                else {
-                    /** Disconnect if write failed */
-                    pClient->disconnect();
-                    return false;
-                }
-
-                if(pChr->canRead()) {
-                    Serial.print("The value of: ");
-                    Serial.print(pChr->getUUID().toString().c_str());
-                    Serial.print(" is now: ");
-                    Serial.println(pChr->readValue().c_str());
-                }
-            }
-
-            /** registerForNotify() has been deprecated and replaced with subscribe() / unsubscribe().
-             *  Subscribe parameter defaults are: notifications=true, notifyCallback=nullptr, response=false.
-             *  Unsubscribe parameter defaults are: response=false.
-             */
-            if(pChr->canNotify()) {
-                //if(!pChr->registerForNotify(notifyCB)) {
-                if(!pChr->subscribe(true, notifyCB)) {
-                    /** Disconnect if subscribe failed */
-                    pClient->disconnect();
-                    return false;
-                }
-            }
-            else if(pChr->canIndicate()) {
-                /** Send false as first argument to subscribe to indications instead of notifications */
-                //if(!pChr->registerForNotify(notifyCB, false)) {
-                if(!pChr->subscribe(false, notifyCB)) {
-                    /** Disconnect if subscribe failed */
-                    pClient->disconnect();
-                    return false;
-                }
-            }
-        }
-
-    } else {
-        Serial.println("BAAD service not found.");
-    }
-
-    Serial.println("Done with this device!");
-    return true;
-}
-
-void setup (){
-    Serial.begin(115200);
-    Serial.println("Starting NimBLE Client");
-    /** Initialize NimBLE, no device name spcified as we are not advertising */
-    NimBLEDevice::init("");
-
-    /** Set the IO capabilities of the device, each option will trigger a different pairing method.
-     *  BLE_HS_IO_KEYBOARD_ONLY    - Passkey pairing
-     *  BLE_HS_IO_DISPLAY_YESNO   - Numeric comparison pairing
-     *  BLE_HS_IO_NO_INPUT_OUTPUT - DEFAULT setting - just works pairing
-     */
-    //NimBLEDevice::setSecurityIOCap(BLE_HS_IO_KEYBOARD_ONLY); // use passkey
-    //NimBLEDevice::setSecurityIOCap(BLE_HS_IO_DISPLAY_YESNO); //use numeric comparison
-
-    /** 2 different ways to set security - both calls achieve the same result.
-     *  no bonding, no man in the middle protection, secure connections.
-     *
-     *  These are the default values, only shown here for demonstration.
-     */
-    //NimBLEDevice::setSecurityAuth(false, false, true);
-    NimBLEDevice::setSecurityAuth(/*BLE_SM_PAIR_AUTHREQ_BOND | BLE_SM_PAIR_AUTHREQ_MITM |*/ BLE_SM_PAIR_AUTHREQ_SC);
-
-    /** Optional: set the transmit power, default is 3db */
-#ifdef ESP_PLATFORM
-    NimBLEDevice::setPower(ESP_PWR_LVL_P9); /** +9db */
-#else
-    NimBLEDevice::setPower(9); /** +9db */
-#endif
-
-    /** Optional: set any devices you don't want to get advertisments from */
-    // NimBLEDevice::addIgnored(NimBLEAddress ("aa:bb:cc:dd:ee:ff"));
-
-    /** create new scan */
-    NimBLEScan* pScan = NimBLEDevice::getScan();
-
-    /** create a callback that gets called when advertisers are found */
-    pScan->setAdvertisedDeviceCallbacks(new AdvertisedDeviceCallbacks());
-
-    /** Set scan interval (how often) and window (how long) in milliseconds */
-    pScan->setInterval(45);
-    pScan->setWindow(15);
-
-    /** Active scan will gather scan response data from advertisers
-     *  but will use more energy from both devices
-     */
-    pScan->setActiveScan(true);
-    /** Start scanning for advertisers for the scan time specified (in seconds) 0 = forever
-     *  Optional callback for when scanning stops.
-     */
-    pScan->start(scanTime, scanEndedCB);
-}
-
-
-void loop (){
-    /** Loop here until we find a device we want to connect to */
-    while(!doConnect){
-        delay(1);
-    }
-
-    doConnect = false;
-
-    /** Found a device we want to connect to, do it now */
-    if(connectToServer()) {
-        Serial.println("Success! we should now be getting notifications, scanning for more!");
-    } else {
-        Serial.println("Failed to connect, starting scan");
-    }
-
-    NimBLEDevice::getScan()->start(scanTime,scanEndedCB);
-}

lib/NimBLE-Arduino/examples/NimBLE_Scan_Continuous/NimBLE_Scan_Continuous.ino

@@ -1,71 +0,0 @@
-/** Example of continuous scanning for BLE advertisements.
- * This example will scan forever while consuming as few resources as possible
- * and report all advertisments on the serial monitor.
- *
- * Created: on January 31 2021
- *      Author: H2zero
- *
- */
-
-#include "NimBLEDevice.h"
-
-NimBLEScan* pBLEScan;
-
-class MyAdvertisedDeviceCallbacks: public NimBLEAdvertisedDeviceCallbacks {
-    void onResult(NimBLEAdvertisedDevice* advertisedDevice) {
-      Serial.printf("Advertised Device: %s \n", advertisedDevice->toString().c_str());
-    }
-};
-
-void setup() {
-  Serial.begin(115200);
-  Serial.println("Scanning...");
-
-/** *Optional* Sets the filtering mode used by the scanner in the BLE controller.
- *
- *  Can be one of:
- *  CONFIG_BTDM_SCAN_DUPL_TYPE_DEVICE (0) (default)
- *  Filter by device address only, advertisements from the same address will be reported only once.
- *
- *  CONFIG_BTDM_SCAN_DUPL_TYPE_DATA (1)
- *  Filter by data only, advertisements with the same data will only be reported once,
- *  even from different addresses.
- *
- *  CONFIG_BTDM_SCAN_DUPL_TYPE_DATA_DEVICE (2)
- *  Filter by address and data, advertisements from the same address will be reported only once,
- *  except if the data in the advertisement has changed, then it will be reported again.
- *
- *  Can only be used BEFORE calling NimBLEDevice::init.
-*/
-  NimBLEDevice::setScanFilterMode(CONFIG_BTDM_SCAN_DUPL_TYPE_DEVICE);
-
-/** *Optional* Sets the scan filter cache size in the BLE controller.
- *  When the number of duplicate advertisements seen by the controller
- *  reaches this value it will clear the cache and start reporting previously
- *  seen devices. The larger this number, the longer time between repeated
- *  device reports. Range 10 - 1000. (default 20)
- *
- *  Can only be used BEFORE calling NimBLEDevice::init.
- */
-  NimBLEDevice::setScanDuplicateCacheSize(200);
-
-  NimBLEDevice::init("");
-
-  pBLEScan = NimBLEDevice::getScan(); //create new scan
-  // Set the callback for when devices are discovered, no duplicates.
-  pBLEScan->setAdvertisedDeviceCallbacks(new MyAdvertisedDeviceCallbacks(), false);
-  pBLEScan->setActiveScan(true); // Set active scanning, this will get more data from the advertiser.
-  pBLEScan->setInterval(97); // How often the scan occurs / switches channels; in milliseconds,
-  pBLEScan->setWindow(37);  // How long to scan during the interval; in milliseconds.
-  pBLEScan->setMaxResults(0); // do not store the scan results, use callback only.
-}
-
-void loop() {
-  // If an error occurs that stops the scan, it will be restarted here.
-  if(pBLEScan->isScanning() == false) {
-      // Start scan with: duration = 0 seconds(forever), no scan end callback, not a continuation of a previous scan.
-      pBLEScan->start(0, nullptr, false);
-  }
-
-  delay(2000);
-}

lib/NimBLE-Arduino/examples/NimBLE_Scan_Whitelist/NimBLE_Scan_whitelist.ino

@@ -1,67 +0,0 @@
-/*
- * NimBLE_Scan_Whitelist demo
- *
- * Created May 16, 2021
- * Author: h2zero
- */
-
-#include <NimBLEDevice.h>
-
-int scanTime = 5; //In seconds
-NimBLEScan* pBLEScan;
-
-class MyAdvertisedDeviceCallbacks: public BLEAdvertisedDeviceCallbacks {
-  void onResult(BLEAdvertisedDevice* advertisedDevice) {
-    Serial.printf("Advertised Device: %s \n", advertisedDevice->toString().c_str());
-    /*
-     * Here we add the device scanned to the whitelist based on service data but any
-     * advertised data can be used for your preffered data.
-     */
-    if (advertisedDevice->haveServiceData()) {
-      /* If this is a device with data we want to capture, add it to the whitelist */
-      if (advertisedDevice->getServiceData(NimBLEUUID("AABB")) != "") {
-        Serial.printf("Adding %s to whitelist\n", std::string(advertisedDevice->getAddress()).c_str());
-        NimBLEDevice::whiteListAdd(advertisedDevice->getAddress());
-      }
-    }
-  }
-};
-
-void setup() {
-  Serial.begin(115200);
-  Serial.println("Scanning...");
-
-  NimBLEDevice::init("");
-  pBLEScan = NimBLEDevice::getScan();
-  pBLEScan->setAdvertisedDeviceCallbacks(new MyAdvertisedDeviceCallbacks());
-  pBLEScan->setActiveScan(true);
-  pBLEScan->setInterval(100);
-  pBLEScan->setFilterPolicy(BLE_HCI_SCAN_FILT_NO_WL);
-  pBLEScan->setWindow(99);
-}
-
-void loop() {
-  NimBLEScanResults foundDevices = pBLEScan->start(scanTime, false);
-  Serial.print("Devices found: ");
-  Serial.println(foundDevices.getCount());
-  Serial.println("Scan done!");
-
-  Serial.println("Whitelist contains:");
-  for (auto i=0; i<NimBLEDevice::getWhiteListCount(); ++i) {
-    Serial.println(NimBLEDevice::getWhiteListAddress(i).toString().c_str());
-  }
-
-  /*
-   * If we have addresses in the whitelist enable the filter unless no devices were found
-   * then scan without so we can find any new devices that we want.
-   */
-  if (NimBLEDevice::getWhiteListCount() > 0) {
-    if (foundDevices.getCount() == 0) {
-      pBLEScan->setFilterPolicy(BLE_HCI_SCAN_FILT_NO_WL);
-    } else {
-      pBLEScan->setFilterPolicy(BLE_HCI_SCAN_FILT_USE_WL);
-    }
-  }
-  pBLEScan->clearResults();
-  delay(2000);
-}

lib/NimBLE-Arduino/examples/NimBLE_Secure_Client/NimBLE_Secure_Client.ino

@@ -1,95 +0,0 @@
-/** NimBLE_Secure_Client Demo:
- *
- * This example demonstrates the secure passkey protected conenction and communication between an esp32 server and an esp32 client.
- * Please note that esp32 stores auth info in nvs memory. After a successful connection it is possible that a passkey change will be ineffective.
- * To avoid this clear the memory of the esp32's between security testings. esptool.py is capable of this, example: esptool.py --port /dev/ttyUSB0 erase_flash.
- *
- *  Created: on Jan 08 2021
- *      Author: mblasee
- */
-
-#include <NimBLEDevice.h>
-
-class ClientCallbacks : public NimBLEClientCallbacks
-{
-  uint32_t onPassKeyRequest()
-  {
-    Serial.println("Client Passkey Request");
-    /** return the passkey to send to the server */
-    /** Change this to be different from NimBLE_Secure_Server if you want to test what happens on key mismatch */
-    return 123456;
-  };
-};
-static ClientCallbacks clientCB;
-
-void setup()
-{
-  Serial.begin(115200);
-  Serial.println("Starting NimBLE Client");
-
-  NimBLEDevice::init("");
-#ifdef ESP_PLATFORM
-    NimBLEDevice::setPower(ESP_PWR_LVL_P9); /** +9db */
-#else
-    NimBLEDevice::setPower(9); /** +9db */
-#endif
-  NimBLEDevice::setSecurityAuth(true, true, true);
-  NimBLEDevice::setSecurityIOCap(BLE_HS_IO_KEYBOARD_ONLY);
-  NimBLEScan *pScan = NimBLEDevice::getScan();
-  NimBLEScanResults results = pScan->start(5);
-
-  NimBLEUUID serviceUuid("ABCD");
-
-  for (int i = 0; i < results.getCount(); i++)
-  {
-    NimBLEAdvertisedDevice device = results.getDevice(i);
-    Serial.println(device.getName().c_str());
-
-    if (device.isAdvertisingService(serviceUuid))
-    {
-      NimBLEClient *pClient = NimBLEDevice::createClient();
-      pClient->setClientCallbacks(&clientCB, false);
-
-      if (pClient->connect(&device))
-      {
-        pClient->secureConnection();
-        NimBLERemoteService *pService = pClient->getService(serviceUuid);
-        if (pService != nullptr)
-        {
-          NimBLERemoteCharacteristic *pNonSecureCharacteristic = pService->getCharacteristic("1234");
-
-          if (pNonSecureCharacteristic != nullptr)
-          {
-            // Testing to read a non secured characteristic, you should be able to read this even if you have mismatching passkeys.
-            std::string value = pNonSecureCharacteristic->readValue();
-            // print or do whatever you need with the value
-            Serial.println(value.c_str());
-          }
-
-          NimBLERemoteCharacteristic *pSecureCharacteristic = pService->getCharacteristic("1235");
-
-          if (pSecureCharacteristic != nullptr)
-          {
-            // Testing to read a secured characteristic, you should be able to read this only if you have matching passkeys, otherwise you should
-            // get an error like this. E NimBLERemoteCharacteristic: "<< readValue rc=261"
-            // This means you are trying to do something without the proper permissions.
-            std::string value = pSecureCharacteristic->readValue();
-            // print or do whatever you need with the value
-            Serial.println(value.c_str());
-          }
-        }
-      }
-      else
-      {
-        // failed to connect
-        Serial.println("failed to connect");
-      }
-
-      NimBLEDevice::deleteClient(pClient);
-    }
-  }
-}
-
-void loop()
-{
-}

lib/NimBLE-Arduino/examples/NimBLE_Secure_Server/NimBLE_Secure_Server.ino

@@ -1,41 +0,0 @@
-/** NimBLE_Secure_Server Demo:
- *
- * This example demonstrates the secure passkey protected conenction and communication between an esp32 server and an esp32 client.
- * Please note that esp32 stores auth info in nvs memory. After a successful connection it is possible that a passkey change will be ineffective.
- * To avoid this clear the memory of the esp32's between security testings. esptool.py is capable of this, example: esptool.py --port /dev/ttyUSB0 erase_flash.
- *
- *  Created: on Jan 08 2021
- *      Author: mblasee
- */
-
-#include <NimBLEDevice.h>
-
-void setup() {
-  Serial.begin(115200);
-  Serial.println("Starting NimBLE Server");
-  NimBLEDevice::init("NimBLE");
-#ifdef ESP_PLATFORM
-    NimBLEDevice::setPower(ESP_PWR_LVL_P9); /** +9db */
-#else
-    NimBLEDevice::setPower(9); /** +9db */
-#endif
-
-  NimBLEDevice::setSecurityAuth(true, true, true);
-  NimBLEDevice::setSecurityPasskey(123456);
-  NimBLEDevice::setSecurityIOCap(BLE_HS_IO_DISPLAY_ONLY);
-  NimBLEServer *pServer = NimBLEDevice::createServer();
-  NimBLEService *pService = pServer->createService("ABCD");
-  NimBLECharacteristic *pNonSecureCharacteristic = pService->createCharacteristic("1234", NIMBLE_PROPERTY::READ );
-  NimBLECharacteristic *pSecureCharacteristic = pService->createCharacteristic("1235", NIMBLE_PROPERTY::READ | NIMBLE_PROPERTY::READ_ENC | NIMBLE_PROPERTY::READ_AUTHEN);
-
-  pService->start();
-  pNonSecureCharacteristic->setValue("Hello Non Secure BLE");
-  pSecureCharacteristic->setValue("Hello Secure BLE");
-
-  NimBLEAdvertising *pAdvertising = NimBLEDevice::getAdvertising();
-  pAdvertising->addServiceUUID("ABCD");
-  pAdvertising->start();
-}
-
-void loop() {
-}

lib/NimBLE-Arduino/examples/NimBLE_Server_Whitelist/NimBLE_Server_Whitelist.ino

@@ -1,105 +0,0 @@
-/*
- * NimBLE_Server_Whitelist demo
- *
- * Created May 17, 2021
- * Author: h2zero
- */
-
-#include <NimBLEDevice.h>
-
-NimBLECharacteristic* pCharacteristic = nullptr;
-bool deviceConnected = false;
-bool oldDeviceConnected = false;
-uint32_t value = 0;
-
-// See the following for generating UUIDs:
-// https://www.uuidgenerator.net/
-
-#define SERVICE_UUID        "4fafc201-1fb5-459e-8fcc-c5c9c331914b"
-#define CHARACTERISTIC_UUID "beb5483e-36e1-4688-b7f5-ea07361b26a8"
-
-
-class MyServerCallbacks: public NimBLEServerCallbacks {
-    void onConnect(NimBLEServer* pServer) {
-      deviceConnected = true;
-    };
-
-    void onDisconnect(NimBLEServer* pServer, ble_gap_conn_desc* desc) {
-      // Peer disconnected, add them to the whitelist
-      // This allows us to use the whitelist to filter connection attempts
-      // which will minimize reconnection time.
-      NimBLEDevice::whiteListAdd(NimBLEAddress(desc->peer_ota_addr));
-      deviceConnected = false;
-    }
-};
-
-void onAdvComplete(NimBLEAdvertising *pAdvertising) {
-    Serial.println("Advertising stopped");
-    if (deviceConnected) {
-        return;
-    }
-    // If advertising timed out without connection start advertising without whitelist filter
-    pAdvertising->setScanFilter(false,false);
-    pAdvertising->start();
-}
-
-
-void setup() {
-  Serial.begin(115200);
-
-  // Create the BLE Device
-  NimBLEDevice::init("ESP32");
-
-  // Create the BLE Server
-  NimBLEServer* pServer = NimBLEDevice::createServer();
-  pServer->setCallbacks(new MyServerCallbacks());
-  pServer->advertiseOnDisconnect(false);
-
-  // Create the BLE Service
-  NimBLEService *pService = pServer->createService(SERVICE_UUID);
-
-  // Create a BLE Characteristic
-  pCharacteristic = pService->createCharacteristic(
-                      CHARACTERISTIC_UUID,
-                      NIMBLE_PROPERTY::READ   |
-                      NIMBLE_PROPERTY::WRITE  |
-                      NIMBLE_PROPERTY::NOTIFY );
-
-  // Start the service
-  pService->start();
-
-  // Start advertising
-  NimBLEAdvertising *pAdvertising = NimBLEDevice::getAdvertising();
-  pAdvertising->addServiceUUID(SERVICE_UUID);
-  pAdvertising->setScanResponse(false);
-  pAdvertising->start();
-  Serial.println("Waiting a client connection to notify...");
-}
-
-void loop() {
-    // notify changed value
-    if (deviceConnected) {
-        pCharacteristic->setValue((uint8_t*)&value, 4);
-        pCharacteristic->notify();
-        value++;
-    }
-    // disconnecting
-    if (!deviceConnected && oldDeviceConnected) {
-        NimBLEAdvertising *pAdvertising = NimBLEDevice::getAdvertising();
-        if (NimBLEDevice::getWhiteListCount() > 0) {
-            // Allow anyone to scan but only whitelisted can connect.
-            pAdvertising->setScanFilter(false,true);
-        }
-        // advertise with whitelist for 30 seconds
-        pAdvertising->start(30, onAdvComplete);
-        Serial.println("start advertising");
-        oldDeviceConnected = deviceConnected;
-    }
-    // connecting
-    if (deviceConnected && !oldDeviceConnected) {
-        // do stuff here on connecting
-        oldDeviceConnected = deviceConnected;
-    }
-
-    delay(2000);
-}

lib/NimBLE-Arduino/examples/NimBLE_Service_Data_Advertiser/NimBLE_Service_Data_Advertiser.ino

@@ -1,33 +0,0 @@
-/** NimBLE_Service_Data_Advertiser Demo:
- *
- *  Simple demo of advertising service data that changes every 5 seconds
- *
- *  Created: on February 7 2021
- *      Author: H2zero
- * 
-*/
-
-#include <NimBLEDevice.h>
-
-#define SERVICE_UUID "4fafc201-1fb5-459e-8fcc-c5c9c331914b"
-
-static NimBLEUUID dataUuid(SERVICE_UUID);
-static NimBLEAdvertising *pAdvertising = NimBLEDevice::getAdvertising();
-static uint32_t count = 0;
-
-void setup() {
-  Serial.begin(115200);
-  Serial.println("Starting BLE work!");
-  
-  NimBLEDevice::init("svc data");
-}
-
-void loop() {
-  pAdvertising->stop();
-  pAdvertising->setServiceData(dataUuid, std::string((char*)&count, sizeof(count)));  
-  pAdvertising->start();
-  
-  Serial.printf("Advertising count = %d\n", count);
-  count++;
-  delay(5000);
-}

lib/NimBLE-Arduino/examples/Refactored_original_examples/BLE_client/BLE_client.ino

@@ -1,194 +0,0 @@
-/**
- * A BLE client example that is rich in capabilities.
- * There is a lot new capabilities implemented.
- * author unknown
- * updated by chegewara
- * updated for NimBLE by H2zero
- */
- 
-/** NimBLE differences highlighted in comment blocks **/
-
-/*******original********
-#include "BLEDevice.h"
-***********************/
-#include "NimBLEDevice.h"
-
-// The remote service we wish to connect to.
-static BLEUUID serviceUUID("4fafc201-1fb5-459e-8fcc-c5c9c331914b");
-// The characteristic of the remote service we are interested in.
-static BLEUUID    charUUID("beb5483e-36e1-4688-b7f5-ea07361b26a8");
-
-static boolean doConnect = false;
-static boolean connected = false;
-static boolean doScan = false;
-static BLERemoteCharacteristic* pRemoteCharacteristic;
-static BLEAdvertisedDevice* myDevice;
-
-static void notifyCallback(
-  BLERemoteCharacteristic* pBLERemoteCharacteristic,
-  uint8_t* pData,
-  size_t length,
-  bool isNotify) {
-    Serial.print("Notify callback for characteristic ");
-    Serial.print(pBLERemoteCharacteristic->getUUID().toString().c_str());
-    Serial.print(" of data length ");
-    Serial.println(length);
-    Serial.print("data: ");
-    Serial.println((char*)pData);
-}
-
-/**  None of these are required as they will be handled by the library with defaults. **
- **                       Remove as you see fit for your needs                        */  
-class MyClientCallback : public BLEClientCallbacks {
-  void onConnect(BLEClient* pclient) {
-  }
-
-  void onDisconnect(BLEClient* pclient) {
-    connected = false;
-    Serial.println("onDisconnect");
-  }
-/***************** New - Security handled here ********************
-****** Note: these are the same return values as defaults ********/
-  uint32_t onPassKeyRequest(){
-    Serial.println("Client PassKeyRequest");
-    return 123456; 
-  }
-  bool onConfirmPIN(uint32_t pass_key){
-    Serial.print("The passkey YES/NO number: ");Serial.println(pass_key);
-    return true; 
-  }
-
-  void onAuthenticationComplete(ble_gap_conn_desc desc){
-    Serial.println("Starting BLE work!");
-  }
-/*******************************************************************/
-};
-
-bool connectToServer() {
-    Serial.print("Forming a connection to ");
-    Serial.println(myDevice->getAddress().toString().c_str());
-    
-    BLEClient*  pClient  = BLEDevice::createClient();
-    Serial.println(" - Created client");
-
-    pClient->setClientCallbacks(new MyClientCallback());
-
-    // Connect to the remove BLE Server.
-    pClient->connect(myDevice);  // if you pass BLEAdvertisedDevice instead of address, it will be recognized type of peer device address (public or private)
-    Serial.println(" - Connected to server");
-
-    // Obtain a reference to the service we are after in the remote BLE server.
-    BLERemoteService* pRemoteService = pClient->getService(serviceUUID);
-    if (pRemoteService == nullptr) {
-      Serial.print("Failed to find our service UUID: ");
-      Serial.println(serviceUUID.toString().c_str());
-      pClient->disconnect();
-      return false;
-    }
-    Serial.println(" - Found our service");
-
-
-    // Obtain a reference to the characteristic in the service of the remote BLE server.
-    pRemoteCharacteristic = pRemoteService->getCharacteristic(charUUID);
-    if (pRemoteCharacteristic == nullptr) {
-      Serial.print("Failed to find our characteristic UUID: ");
-      Serial.println(charUUID.toString().c_str());
-      pClient->disconnect();
-      return false;
-    }
-    Serial.println(" - Found our characteristic");
-
-    // Read the value of the characteristic.
-    if(pRemoteCharacteristic->canRead()) {
-      std::string value = pRemoteCharacteristic->readValue();
-      Serial.print("The characteristic value was: ");
-      Serial.println(value.c_str());
-    }
-
-    if(pRemoteCharacteristic->canNotify())
-      pRemoteCharacteristic->registerForNotify(notifyCallback);
-
-    connected = true;
-    return true;
-}
-
-/**
- * Scan for BLE servers and find the first one that advertises the service we are looking for.
- */
-class MyAdvertisedDeviceCallbacks: public BLEAdvertisedDeviceCallbacks {
- /**
-   * Called for each advertising BLE server.
-   */
-   
-/*** Only a reference to the advertised device is passed now
-  void onResult(BLEAdvertisedDevice advertisedDevice) { **/     
-  void onResult(BLEAdvertisedDevice* advertisedDevice) {
-    Serial.print("BLE Advertised Device found: ");
-    Serial.println(advertisedDevice->toString().c_str());
-
-    // We have found a device, let us now see if it contains the service we are looking for.
-/********************************************************************************
-    if (advertisedDevice.haveServiceUUID() && advertisedDevice.isAdvertisingService(serviceUUID)) {
-********************************************************************************/
-    if (advertisedDevice->haveServiceUUID() && advertisedDevice->isAdvertisingService(serviceUUID)) {
-
-      BLEDevice::getScan()->stop();
-/*******************************************************************
-      myDevice = new BLEAdvertisedDevice(advertisedDevice);
-*******************************************************************/
-      myDevice = advertisedDevice; /** Just save the reference now, no need to copy the object */
-      doConnect = true;
-      doScan = true;
-
-    } // Found our server
-  } // onResult
-}; // MyAdvertisedDeviceCallbacks
-
-
-void setup() {
-  Serial.begin(115200);
-  Serial.println("Starting Arduino BLE Client application...");
-  BLEDevice::init("");
-
-  // Retrieve a Scanner and set the callback we want to use to be informed when we
-  // have detected a new device.  Specify that we want active scanning and start the
-  // scan to run for 5 seconds.
-  BLEScan* pBLEScan = BLEDevice::getScan();
-  pBLEScan->setAdvertisedDeviceCallbacks(new MyAdvertisedDeviceCallbacks());
-  pBLEScan->setInterval(1349);
-  pBLEScan->setWindow(449);
-  pBLEScan->setActiveScan(true);
-  pBLEScan->start(5, false);
-} // End of setup.
-
-
-// This is the Arduino main loop function.
-void loop() {
-
-  // If the flag "doConnect" is true then we have scanned for and found the desired
-  // BLE Server with which we wish to connect.  Now we connect to it.  Once we are 
-  // connected we set the connected flag to be true.
-  if (doConnect == true) {
-    if (connectToServer()) {
-      Serial.println("We are now connected to the BLE Server.");
-    } else {
-      Serial.println("We have failed to connect to the server; there is nothin more we will do.");
-    }
-    doConnect = false;
-  }
-
-  // If we are connected to a peer BLE Server, update the characteristic each time we are reached
-  // with the current time since boot.
-  if (connected) {
-    String newValue = "Time since boot: " + String(millis()/1000);
-    Serial.println("Setting new characteristic value to \"" + newValue + "\"");
-    
-    // Set the characteristic's value to be the array of bytes that is actually a string.
-    /*** Note: write / read value now returns true if successful, false otherwise - try again or disconnect ***/
-    pRemoteCharacteristic->writeValue(newValue.c_str(), newValue.length());
-  }else if(doScan){
-    BLEDevice::getScan()->start(0);  // this is just eample to start scan after disconnect, most likely there is better way to do it in arduino
-  }
-  
-  delay(1000); // Delay a second between loops.
-} // End of loop

lib/NimBLE-Arduino/examples/Refactored_original_examples/BLE_iBeacon/BLE_iBeacon.ino

@@ -1,118 +0,0 @@
-/*
-   Based on Neil Kolban example for IDF: https://github.com/nkolban/esp32-snippets/blob/master/cpp_utils/tests/BLE%20Tests/SampleScan.cpp
-   Ported to Arduino ESP32 by pcbreflux
-*/
-
- 
-/*
-   Create a BLE server that will send periodic iBeacon frames.
-   The design of creating the BLE server is:
-   1. Create a BLE Server
-   2. Create advertising data
-   3. Start advertising.
-   4. wait
-   5. Stop advertising.
-   6. deep sleep
-   
-*/
-
-
-/** NimBLE differences highlighted in comment blocks **/
-
-
-#include "sys/time.h"
-/*******original********
-#include "BLEDevice.h"
-#include "BLEUtils.h"
-#include "BLEBeacon.h"
-***********************/
-#include "NimBLEDevice.h"
-#include "NimBLEBeacon.h"
-#include "esp_sleep.h"
-
-#define GPIO_DEEP_SLEEP_DURATION     10  // sleep x seconds and then wake up
-RTC_DATA_ATTR static time_t last;        // remember last boot in RTC Memory
-RTC_DATA_ATTR static uint32_t bootcount; // remember number of boots in RTC Memory
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-uint8_t temprature_sens_read();
-//uint8_t g_phyFuns;
-
-#ifdef __cplusplus
-}
-#endif
-
-// See the following for generating UUIDs:
-// https://www.uuidgenerator.net/
-BLEAdvertising *pAdvertising;
-struct timeval now;
-
-#define BEACON_UUID           "8ec76ea3-6668-48da-9866-75be8bc86f4d" // UUID 1 128-Bit (may use linux tool uuidgen or random numbers via https://www.uuidgenerator.net/)
-
-void setBeacon() {
-
-  BLEBeacon oBeacon = BLEBeacon();
-  oBeacon.setManufacturerId(0x4C00); // fake Apple 0x004C LSB (ENDIAN_CHANGE_U16!)
-  oBeacon.setProximityUUID(BLEUUID(BEACON_UUID));
-  oBeacon.setMajor((bootcount & 0xFFFF0000) >> 16);
-  oBeacon.setMinor(bootcount&0xFFFF);
-  BLEAdvertisementData oAdvertisementData = BLEAdvertisementData();
-  BLEAdvertisementData oScanResponseData = BLEAdvertisementData();
-  
-  oAdvertisementData.setFlags(0x04); // BR_EDR_NOT_SUPPORTED 0x04
-  
-  std::string strServiceData = "";
-  
-  strServiceData += (char)26;     // Len
-  strServiceData += (char)0xFF;   // Type
-  strServiceData += oBeacon.getData(); 
-  oAdvertisementData.addData(strServiceData);
-  
-  pAdvertising->setAdvertisementData(oAdvertisementData);
-  pAdvertising->setScanResponseData(oScanResponseData);
-  /**  pAdvertising->setAdvertisementType(ADV_TYPE_NONCONN_IND);
-  *    Advertising mode. Can be one of following constants:
-  *  - BLE_GAP_CONN_MODE_NON (non-connectable; 3.C.9.3.2).
-  *  - BLE_GAP_CONN_MODE_DIR (directed-connectable; 3.C.9.3.3).
-  *  - BLE_GAP_CONN_MODE_UND (undirected-connectable; 3.C.9.3.4).
-  */
-  pAdvertising->setAdvertisementType(BLE_GAP_CONN_MODE_NON);
-
-}
-
-void setup() {
-
-    
-  Serial.begin(115200);
-  gettimeofday(&now, NULL);
-
-  Serial.printf("start ESP32 %d\n",bootcount++);
-
-  Serial.printf("deep sleep (%lds since last reset, %lds since last boot)\n",now.tv_sec,now.tv_sec-last);
-
-  last = now.tv_sec;
-  
-  // Create the BLE Device
-  BLEDevice::init("");
-
-  // Create the BLE Server
-  // BLEServer *pServer = BLEDevice::createServer(); // <-- no longer required to instantiate BLEServer, less flash and ram usage
-
-  pAdvertising = BLEDevice::getAdvertising();
-  
-  setBeacon();
-   // Start advertising
-  pAdvertising->start();
-  Serial.println("Advertizing started...");
-  delay(100);
-  pAdvertising->stop();
-  Serial.printf("enter deep sleep\n");
-  esp_deep_sleep(1000000LL * GPIO_DEEP_SLEEP_DURATION);
-  Serial.printf("in deep sleep\n");
-}
-
-void loop() {
-}

lib/NimBLE-Arduino/examples/Refactored_original_examples/BLE_scan/BLE_scan.ino

@@ -1,49 +0,0 @@
-/*
-   Based on Neil Kolban example for IDF: https://github.com/nkolban/esp32-snippets/blob/master/cpp_utils/tests/BLE%20Tests/SampleScan.cpp
-   Ported to Arduino ESP32 by Evandro Copercini
-*/
-
-/** NimBLE differences highlighted in comment blocks **/
-
-/*******original********
-#include <BLEDevice.h>
-#include <BLEUtils.h>
-#include <BLEScan.h>
-#include <BLEAdvertisedDevice.h>
-***********************/
-
-#include <NimBLEDevice.h>
-
-int scanTime = 5; //In seconds
-BLEScan* pBLEScan;
-
-class MyAdvertisedDeviceCallbacks: public BLEAdvertisedDeviceCallbacks {
-  /*** Only a reference to the advertised device is passed now
-    void onResult(BLEAdvertisedDevice advertisedDevice) { **/
-    void onResult(BLEAdvertisedDevice* advertisedDevice) {
-  /** Serial.printf("Advertised Device: %s \n", advertisedDevice.toString().c_str()); **/
-      Serial.printf("Advertised Device: %s \n", advertisedDevice->toString().c_str());
-    }
-};
-
-void setup() {
-  Serial.begin(115200);
-  Serial.println("Scanning...");
-
-  BLEDevice::init("");
-  pBLEScan = BLEDevice::getScan(); //create new scan
-  pBLEScan->setAdvertisedDeviceCallbacks(new MyAdvertisedDeviceCallbacks());
-  pBLEScan->setActiveScan(true); //active scan uses more power, but get results faster
-  pBLEScan->setInterval(100);
-  pBLEScan->setWindow(99);  // less or equal setInterval value
-}
-
-void loop() {
-  // put your main code here, to run repeatedly:
-  BLEScanResults foundDevices = pBLEScan->start(scanTime, false);
-  Serial.print("Devices found: ");
-  Serial.println(foundDevices.getCount());
-  Serial.println("Scan done!");
-  pBLEScan->clearResults();   // delete results fromBLEScan buffer to release memory
-  delay(2000);
-}

lib/NimBLE-Arduino/examples/Refactored_original_examples/BLE_server_multiconnect/BLE_server_multiconnect.ino

@@ -1,150 +0,0 @@
-/*
-    Video: https://www.youtube.com/watch?v=oCMOYS71NIU
-    Based on Neil Kolban example for IDF: https://github.com/nkolban/esp32-snippets/blob/master/cpp_utils/tests/BLE%20Tests/SampleNotify.cpp
-    Ported to Arduino ESP32 by Evandro Copercini
-    updated by chegewara
-
-   Create a BLE server that, once we receive a connection, will send periodic notifications.
-   The service advertises itself as: 4fafc201-1fb5-459e-8fcc-c5c9c331914b
-   And has a characteristic of: beb5483e-36e1-4688-b7f5-ea07361b26a8
-
-   The design of creating the BLE server is:
-   1. Create a BLE Server
-   2. Create a BLE Service
-   3. Create a BLE Characteristic on the Service
-   4. Create a BLE Descriptor on the characteristic
-   5. Start the service.
-   6. Start advertising.
-
-   A connect hander associated with the server starts a background task that performs notification
-   every couple of seconds.
-*/
-
-/** NimBLE differences highlighted in comment blocks **/
-
-/*******original********
-#include <BLEDevice.h>
-#include <BLEServer.h>
-#include <BLEUtils.h>
-#include <BLE2902.h>
-***********************/
-#include <NimBLEDevice.h>
-
-BLEServer* pServer = NULL;
-BLECharacteristic* pCharacteristic = NULL;
-bool deviceConnected = false;
-bool oldDeviceConnected = false;
-uint32_t value = 0;
-
-// See the following for generating UUIDs:
-// https://www.uuidgenerator.net/
-
-#define SERVICE_UUID        "4fafc201-1fb5-459e-8fcc-c5c9c331914b"
-#define CHARACTERISTIC_UUID "beb5483e-36e1-4688-b7f5-ea07361b26a8"
-
-
-/**  None of these are required as they will be handled by the library with defaults. **
- **                       Remove as you see fit for your needs                        */  
-class MyServerCallbacks: public BLEServerCallbacks {
-    void onConnect(BLEServer* pServer) {
-      deviceConnected = true;
-      BLEDevice::startAdvertising();
-    };
-
-    void onDisconnect(BLEServer* pServer) {
-      deviceConnected = false;
-    }
-  /***************** New - Security handled here ********************
-  ****** Note: these are the same return values as defaults ********/
-    uint32_t onPassKeyRequest(){
-      Serial.println("Server PassKeyRequest");
-      return 123456; 
-    }
-
-    bool onConfirmPIN(uint32_t pass_key){
-      Serial.print("The passkey YES/NO number: ");Serial.println(pass_key);
-      return true; 
-    }
-
-    void onAuthenticationComplete(ble_gap_conn_desc desc){
-      Serial.println("Starting BLE work!");
-    }
-  /*******************************************************************/
-};
-
-
-
-void setup() {
-  Serial.begin(115200);
-
-  // Create the BLE Device
-  BLEDevice::init("ESP32");
-
-  // Create the BLE Server
-  pServer = BLEDevice::createServer();
-  pServer->setCallbacks(new MyServerCallbacks());
-
-  // Create the BLE Service
-  BLEService *pService = pServer->createService(SERVICE_UUID);
-
-  // Create a BLE Characteristic
-  pCharacteristic = pService->createCharacteristic(
-                      CHARACTERISTIC_UUID,
-                /******* Enum Type NIMBLE_PROPERTY now *******     
-                      BLECharacteristic::PROPERTY_READ   |
-                      BLECharacteristic::PROPERTY_WRITE  |
-                      BLECharacteristic::PROPERTY_NOTIFY |
-                      BLECharacteristic::PROPERTY_INDICATE
-                    );
-                **********************************************/    
-                      NIMBLE_PROPERTY::READ   |
-                      NIMBLE_PROPERTY::WRITE  |
-                      NIMBLE_PROPERTY::NOTIFY |
-                      NIMBLE_PROPERTY::INDICATE
-                    );
-
-  // https://www.bluetooth.com/specifications/gatt/viewer?attributeXmlFile=org.bluetooth.descriptor.gatt.client_characteristic_configuration.xml
-  // Create a BLE Descriptor
-  /***************************************************   
-   NOTE: DO NOT create a 2902 descriptor 
-   it will be created automatically if notifications 
-   or indications are enabled on a characteristic.
-   
-   pCharacteristic->addDescriptor(new BLE2902());
-  ****************************************************/
-
-  // Start the service
-  pService->start();
-
-  // Start advertising
-  BLEAdvertising *pAdvertising = BLEDevice::getAdvertising();
-  pAdvertising->addServiceUUID(SERVICE_UUID);
-  pAdvertising->setScanResponse(false);
-  /** Note, this could be left out as that is the default value */
-  pAdvertising->setMinPreferred(0x0);  // set value to 0x00 to not advertise this parameter
-
-  BLEDevice::startAdvertising();
-  Serial.println("Waiting a client connection to notify...");
-}
-
-void loop() {
-    // notify changed value
-    if (deviceConnected) {
-        pCharacteristic->setValue((uint8_t*)&value, 4);
-        pCharacteristic->notify();
-        value++;
-        delay(10); // bluetooth stack will go into congestion, if too many packets are sent, in 6 hours test i was able to go as low as 3ms
-    }
-    // disconnecting
-    if (!deviceConnected && oldDeviceConnected) {
-        delay(500); // give the bluetooth stack the chance to get things ready
-        pServer->startAdvertising(); // restart advertising
-        Serial.println("start advertising");
-        oldDeviceConnected = deviceConnected;
-    }
-    // connecting
-    if (deviceConnected && !oldDeviceConnected) {
-        // do stuff here on connecting
-        oldDeviceConnected = deviceConnected;
-    }
-}

lib/NimBLE-Arduino/examples/Refactored_original_examples/BLE_write/BLE_write.ino

@@ -1,75 +0,0 @@
-/*
-    Based on Neil Kolban example for IDF: https://github.com/nkolban/esp32-snippets/blob/master/cpp_utils/tests/BLE%20Tests/SampleWrite.cpp
-    Ported to Arduino ESP32 by Evandro Copercini
-*/
-
-/** NimBLE differences highlighted in comment blocks **/
-
-/*******original********
-#include <BLEDevice.h>
-#include <BLEUtils.h>
-#include <BLEServer.h>
-***********************/
-#include <NimBLEDevice.h>
-
-// See the following for generating UUIDs:
-// https://www.uuidgenerator.net/
-
-#define SERVICE_UUID        "4fafc201-1fb5-459e-8fcc-c5c9c331914b"
-#define CHARACTERISTIC_UUID "beb5483e-36e1-4688-b7f5-ea07361b26a8"
-
-
-class MyCallbacks: public BLECharacteristicCallbacks {
-    void onWrite(BLECharacteristic *pCharacteristic) {
-      std::string value = pCharacteristic->getValue();
-
-      if (value.length() > 0) {
-        Serial.println("*********");
-        Serial.print("New value: ");
-        for (int i = 0; i < value.length(); i++)
-          Serial.print(value[i]);
-
-        Serial.println();
-        Serial.println("*********");
-      }
-    }
-};
-
-void setup() {
-  Serial.begin(115200);
-
-  Serial.println("1- Download and install an BLE scanner app in your phone");
-  Serial.println("2- Scan for BLE devices in the app");
-  Serial.println("3- Connect to MyESP32");
-  Serial.println("4- Go to CUSTOM CHARACTERISTIC in CUSTOM SERVICE and write something");
-  Serial.println("5- See the magic =)");
-
-  BLEDevice::init("MyESP32");
-  BLEServer *pServer = BLEDevice::createServer();
-
-  BLEService *pService = pServer->createService(SERVICE_UUID);
-
-  BLECharacteristic *pCharacteristic = pService->createCharacteristic(
-                                        CHARACTERISTIC_UUID,
-                                  /***** Enum Type NIMBLE_PROPERTY now *****      
-                                        BLECharacteristic::PROPERTY_READ   |
-                                        BLECharacteristic::PROPERTY_WRITE  
-                                        );
-                                  *****************************************/
-                                        NIMBLE_PROPERTY::READ |
-                                        NIMBLE_PROPERTY::WRITE 
-                                       );
-
-  pCharacteristic->setCallbacks(new MyCallbacks());
-
-  pCharacteristic->setValue("Hello World");
-  pService->start();
-
-  BLEAdvertising *pAdvertising = pServer->getAdvertising();
-  pAdvertising->start();
-}
-
-void loop() {
-  // put your main code here, to run repeatedly:
-  delay(2000);
-}

lib/NimBLE-Arduino/src/NimBLEConnInfo.h

@@ -1,55 +0,0 @@
-#ifndef NIMBLECONNINFO_H_
-#define NIMBLECONNINFO_H_
-
-#include "NimBLEAddress.h"
-
-/**
- * @brief Connection information.
- */
-class NimBLEConnInfo {
-friend class NimBLEServer;
-friend class NimBLEClient;
-    ble_gap_conn_desc m_desc;
-    NimBLEConnInfo()                       { m_desc = {}; }
-    NimBLEConnInfo(ble_gap_conn_desc desc) { m_desc = desc; }
-public:
-    /** @brief Gets the over-the-air address of the connected peer */
-    NimBLEAddress    getAddress()          { return NimBLEAddress(m_desc.peer_ota_addr); }
-
-    /** @brief Gets the ID address of the connected peer */
-    NimBLEAddress    getIdAddress()        { return NimBLEAddress(m_desc.peer_id_addr); }
-
-    /** @brief Gets the connection handle of the connected peer */
-    uint16_t         getConnHandle()       { return m_desc.conn_handle; }
-
-    /** @brief Gets the connection interval for this connection (in 1.25ms units) */
-    uint16_t         getConnInterval()     { return m_desc.conn_itvl; }
-
-    /** @brief Gets the supervision timeout for this connection (in 10ms units) */
-    uint16_t         getConnTimeout()      { return m_desc.supervision_timeout; }
-
-    /** @brief Gets the allowable latency for this connection (unit = number of intervals) */
-    uint16_t         getConnLatency()      { return m_desc.conn_latency; }
-
-    /** @brief Gets the maximum transmission unit size for this connection (in bytes) */
-    uint16_t         getMTU()              { return ble_att_mtu(m_desc.conn_handle); }
-
-    /** @brief Check if we are in the master role in this connection */
-    bool             isMaster()            { return (m_desc.role == BLE_GAP_ROLE_MASTER); }
-
-    /** @brief Check if we are in the slave role in this connection */
-    bool             isSlave()             { return (m_desc.role == BLE_GAP_ROLE_SLAVE); }
-
-    /** @brief Check if we are connected to a bonded peer */
-    bool             isBonded()            { return (m_desc.sec_state.bonded == 1); }
-
-    /** @brief Check if the connection in encrypted */
-    bool             isEncrypted()         { return (m_desc.sec_state.encrypted == 1); }
-
-    /** @brief Check if the the connection has been authenticated */
-    bool             isAuthenticated()     { return (m_desc.sec_state.authenticated == 1); }
-
-    /** @brief Gets the key size used to encrypt the connection */
-    uint8_t          getSecKeySize()       { return m_desc.sec_state.key_size; }
-};
-#endif