Remove old and modified libs, switch to ESPAsyncWebserver, add support for ESP32-H2 and multiple Ethernet modules (#455)

* Asyncwebserver

* Squashed commit of the following:

commit 575ef02f593918ec6654c87407a4d11fc17071b8
Author: technyon <j.o.schuemann@gmx.de>
Date:   Mon Aug 12 17:56:11 2024 +0200

    merge master

commit 35e5adf4ecd80f9829e8801181f35dd2c1d94759
Merge: a2cc7be2 21adca01
Author: technyon <j.o.schuemann@gmx.de>
Date:   Mon Aug 12 17:41:04 2024 +0200

    Merge branch 'master' of github.com:technyon/nuki_hub into DM9051

commit a2cc7be2954cbd8767ab8186296c0b14134d1d0b
Author: technyon <j.o.schuemann@gmx.de>
Date:   Mon Aug 12 10:51:50 2024 +0200

    update nuki ble

commit 20c809f3dca28b29b219d1ff3a183f1981316de5
Author: technyon <j.o.schuemann@gmx.de>
Date:   Mon Aug 12 10:44:46 2024 +0200

    backup

commit dd41c218efb5270f5efeb734e64dff695920db16
Merge: 153000b5 e84b944a
Author: technyon <j.o.schuemann@gmx.de>
Date:   Mon Aug 12 10:40:03 2024 +0200

    Merge branch 'master' of github.com:technyon/nuki_hub into DM9051

commit 153000b5b1af7df1fbeb5263df94eb26f689cc0a
Author: technyon <j.o.schuemann@gmx.de>
Date:   Mon Aug 12 10:23:07 2024 +0200

    fix linker error

commit a93bbfbfc4301e46ff3696a763dd13c6c89efefb
Author: technyon <j.o.schuemann@gmx.de>
Date:   Sun Aug 11 11:27:07 2024 +0200

    backup

commit f611c75ce8c35f829bcad6cf7e86188f4b3ec331
Merge: f1964917 063fbab6
Author: technyon <j.o.schuemann@gmx.de>
Date:   Sun Aug 11 11:24:47 2024 +0200

    merge master

commit f1964917b4dade3920f1ecdb699c58630199e6da
Author: technyon <j.o.schuemann@gmx.de>
Date:   Sat Aug 10 15:17:45 2024 +0200

    update platformio.ini

commit f448e5e8a7e93be38e09e2ab0b622199a3721af6
Author: technyon <j.o.schuemann@gmx.de>
Date:   Sat Aug 10 11:28:09 2024 +0200

    add SPIClass instance for DM9051

commit 1f190e9aa08033535a2eb442a92e6e20409bbda1
Author: technyon <j.o.schuemann@gmx.de>
Date:   Sat Aug 10 11:22:26 2024 +0200

    add definitions and constructor for DM9051

commit 726b3602ae91594ee1210ad5b6714f75cc5e42a7
Merge: 50a2eb13 4af90cbc
Author: technyon <j.o.schuemann@gmx.de>
Date:   Sat Aug 10 10:19:34 2024 +0200

    merge master

commit 50a2eb136d75d90921f1c6974f18bc107bddc123
Author: technyon <j.o.schuemann@gmx.de>
Date:   Fri Aug 9 11:52:09 2024 +0200

    add comment

commit 9437e485cae169efdf8e5a7bf188a1c7e792d1e5
Author: technyon <j.o.schuemann@gmx.de>
Date:   Sun Aug 4 08:29:21 2024 +0200

    move LAN8720 definitions to seperate file

* Remove Core 2 Ethernet library

* Custom Ethernet

* GPIO and Preferences

* H2

lib/ESPAsyncWebServer/src/AsyncEventSource.cpp

@@ -0,0 +1,405 @@
+/*
+  Asynchronous WebServer library for Espressif MCUs
+
+  Copyright (c) 2016 Hristo Gochkov. All rights 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"
+#if defined(ESP32)
+  #include <rom/ets_sys.h>
+#endif
+#include "AsyncEventSource.h"
+#include "literals.h"
+
+using namespace asyncsrv;
+
+static String generateEventMessage(const char* message, const char* event, uint32_t id, uint32_t reconnect) {
+  String ev;
+
+  if (reconnect) {
+    ev += T_retry_;
+    ev += reconnect;
+    ev += T_rn;
+  }
+
+  if (id) {
+    ev += T_id__;
+    ev += id;
+    ev += T_rn;
+  }
+
+  if (event != NULL) {
+    ev += T_event_;
+    ev += event;
+    ev += T_rn;
+  }
+
+  if (message != NULL) {
+    size_t messageLen = strlen(message);
+    char* lineStart = (char*)message;
+    char* lineEnd;
+    do {
+      char* nextN = strchr(lineStart, '\n');
+      char* nextR = strchr(lineStart, '\r');
+      if (nextN == NULL && nextR == NULL) {
+        size_t llen = ((char*)message + messageLen) - lineStart;
+        char* ldata = (char*)malloc(llen + 1);
+        if (ldata != NULL) {
+          memcpy(ldata, lineStart, llen);
+          ldata[llen] = 0;
+          ev += T_data_;
+          ev += ldata;
+          ev += T_rnrn;
+          free(ldata);
+        }
+        lineStart = (char*)message + messageLen;
+      } else {
+        char* nextLine = NULL;
+        if (nextN != NULL && nextR != NULL) {
+          if (nextR < nextN) {
+            lineEnd = nextR;
+            if (nextN == (nextR + 1))
+              nextLine = nextN + 1;
+            else
+              nextLine = nextR + 1;
+          } else {
+            lineEnd = nextN;
+            if (nextR == (nextN + 1))
+              nextLine = nextR + 1;
+            else
+              nextLine = nextN + 1;
+          }
+        } else if (nextN != NULL) {
+          lineEnd = nextN;
+          nextLine = nextN + 1;
+        } else {
+          lineEnd = nextR;
+          nextLine = nextR + 1;
+        }
+
+        size_t llen = lineEnd - lineStart;
+        char* ldata = (char*)malloc(llen + 1);
+        if (ldata != NULL) {
+          memcpy(ldata, lineStart, llen);
+          ldata[llen] = 0;
+          ev += T_data_;
+          ev += ldata;
+          ev += T_rn;
+          free(ldata);
+        }
+        lineStart = nextLine;
+        if (lineStart == ((char*)message + messageLen))
+          ev += T_rn;
+      }
+    } while (lineStart < ((char*)message + messageLen));
+  }
+
+  return ev;
+}
+
+// Message
+
+AsyncEventSourceMessage::AsyncEventSourceMessage(const char* data, size_t len)
+    : _data(nullptr), _len(len), _sent(0), _acked(0) {
+  _data = (uint8_t*)malloc(_len + 1);
+  if (_data == nullptr) {
+    _len = 0;
+  } else {
+    memcpy(_data, data, len);
+    _data[_len] = 0;
+  }
+}
+
+AsyncEventSourceMessage::~AsyncEventSourceMessage() {
+  if (_data != NULL)
+    free(_data);
+}
+
+size_t AsyncEventSourceMessage::ack(size_t len, uint32_t time) {
+  (void)time;
+  // If the whole message is now acked...
+  if (_acked + len > _len) {
+    // Return the number of extra bytes acked (they will be carried on to the next message)
+    const size_t extra = _acked + len - _len;
+    _acked = _len;
+    return extra;
+  }
+  // Return that no extra bytes left.
+  _acked += len;
+  return 0;
+}
+
+// This could also return void as the return value is not used.
+// Leaving as-is for compatibility...
+size_t AsyncEventSourceMessage::send(AsyncClient* client) {
+  if (_sent >= _len) {
+    return 0;
+  }
+  const size_t len_to_send = _len - _sent;
+  auto position = reinterpret_cast<const char*>(_data + _sent);
+  const size_t sent_now = client->write(position, len_to_send);
+  _sent += sent_now;
+  return sent_now;
+}
+
+// Client
+
+AsyncEventSourceClient::AsyncEventSourceClient(AsyncWebServerRequest* request, AsyncEventSource* server) {
+  _client = request->client();
+  _server = server;
+  _lastId = 0;
+  if (request->hasHeader(T_Last_Event_ID))
+    _lastId = atoi(request->getHeader(T_Last_Event_ID)->value().c_str());
+
+  _client->setRxTimeout(0);
+  _client->onError(NULL, NULL);
+  _client->onAck([](void* r, AsyncClient* c, size_t len, uint32_t time) { (void)c; ((AsyncEventSourceClient*)(r))->_onAck(len, time); }, this);
+  _client->onPoll([](void* r, AsyncClient* c) { (void)c; ((AsyncEventSourceClient*)(r))->_onPoll(); }, this);
+  _client->onData(NULL, NULL);
+  _client->onTimeout([this](void* r, AsyncClient* c __attribute__((unused)), uint32_t time) { ((AsyncEventSourceClient*)(r))->_onTimeout(time); }, this);
+  _client->onDisconnect([this](void* r, AsyncClient* c) { ((AsyncEventSourceClient*)(r))->_onDisconnect(); delete c; }, this);
+
+  _server->_addClient(this);
+  delete request;
+}
+
+AsyncEventSourceClient::~AsyncEventSourceClient() {
+#ifdef ESP32
+  std::lock_guard<std::mutex> lock(_lockmq);
+#endif
+  _messageQueue.clear();
+  close();
+}
+
+void AsyncEventSourceClient::_queueMessage(const char* message, size_t len) {
+#ifdef ESP32
+  // length() is not thread-safe, thus acquiring the lock before this call..
+  std::lock_guard<std::mutex> lock(_lockmq);
+#endif
+
+  if (_messageQueue.size() >= SSE_MAX_QUEUED_MESSAGES) {
+#ifdef ESP8266
+    ets_printf(String(F("ERROR: Too many messages queued\n")).c_str());
+#elif defined(ESP32)
+    log_e("Too many messages queued: deleting message");
+#endif
+    return;
+  }
+
+  _messageQueue.emplace_back(message, len);
+  // runqueue trigger when new messages added
+  if (_client->canSend()) {
+    _runQueue();
+  }
+}
+
+void AsyncEventSourceClient::_onAck(size_t len, uint32_t time) {
+#ifdef ESP32
+  // Same here, acquiring the lock early
+  std::lock_guard<std::mutex> lock(_lockmq);
+#endif
+  while (len && _messageQueue.size()) {
+    len = _messageQueue.front().ack(len, time);
+    if (_messageQueue.front().finished())
+      _messageQueue.pop_front();
+  }
+  _runQueue();
+}
+
+void AsyncEventSourceClient::_onPoll() {
+#ifdef ESP32
+  // Same here, acquiring the lock early
+  std::lock_guard<std::mutex> lock(_lockmq);
+#endif
+  if (_messageQueue.size()) {
+    _runQueue();
+  }
+}
+
+void AsyncEventSourceClient::_onTimeout(uint32_t time __attribute__((unused))) {
+  _client->close(true);
+}
+
+void AsyncEventSourceClient::_onDisconnect() {
+  _client = NULL;
+  _server->_handleDisconnect(this);
+}
+
+void AsyncEventSourceClient::close() {
+  if (_client != NULL)
+    _client->close();
+}
+
+void AsyncEventSourceClient::write(const char* message, size_t len) {
+  if (!connected())
+    return;
+  _queueMessage(message, len);
+}
+
+void AsyncEventSourceClient::send(const char* message, const char* event, uint32_t id, uint32_t reconnect) {
+  if (!connected())
+    return;
+  String ev = generateEventMessage(message, event, id, reconnect);
+  _queueMessage(ev.c_str(), ev.length());
+}
+
+size_t AsyncEventSourceClient::packetsWaiting() const {
+#ifdef ESP32
+  std::lock_guard<std::mutex> lock(_lockmq);
+#endif
+  return _messageQueue.size();
+}
+
+void AsyncEventSourceClient::_runQueue() {
+  // Calls to this private method now already protected by _lockmq acquisition
+  // so no extra call of _lockmq.lock() here..
+  for (auto& i : _messageQueue) {
+    if (!i.sent())
+      i.send(_client);
+  }
+}
+
+// Handler
+void AsyncEventSource::onConnect(ArEventHandlerFunction cb) {
+  _connectcb = cb;
+}
+
+void AsyncEventSource::authorizeConnect(ArAuthorizeConnectHandler cb) {
+  _authorizeConnectHandler = cb;
+}
+
+void AsyncEventSource::_addClient(AsyncEventSourceClient* client) {
+  if (!client)
+    return;
+#ifdef ESP32
+  std::lock_guard<std::mutex> lock(_client_queue_lock);
+#endif
+  _clients.emplace_back(client);
+  if (_connectcb)
+    _connectcb(client);
+}
+
+void AsyncEventSource::_handleDisconnect(AsyncEventSourceClient* client) {
+#ifdef ESP32
+  std::lock_guard<std::mutex> lock(_client_queue_lock);
+#endif
+  for (auto i = _clients.begin(); i != _clients.end(); ++i) {
+    if (i->get() == client)
+      _clients.erase(i);
+  }
+}
+
+void AsyncEventSource::close() {
+  // While the whole loop is not done, the linked list is locked and so the
+  // iterator should remain valid even when AsyncEventSource::_handleDisconnect()
+  // is called very early
+#ifdef ESP32
+  std::lock_guard<std::mutex> lock(_client_queue_lock);
+#endif
+  for (const auto& c : _clients) {
+    if (c->connected())
+      c->close();
+  }
+}
+
+// pmb fix
+size_t AsyncEventSource::avgPacketsWaiting() const {
+  size_t aql = 0;
+  uint32_t nConnectedClients = 0;
+#ifdef ESP32
+  std::lock_guard<std::mutex> lock(_client_queue_lock);
+#endif
+  if (!_clients.size())
+    return 0;
+
+  for (const auto& c : _clients) {
+    if (c->connected()) {
+      aql += c->packetsWaiting();
+      ++nConnectedClients;
+    }
+  }
+  return ((aql) + (nConnectedClients / 2)) / (nConnectedClients); // round up
+}
+
+void AsyncEventSource::send(
+  const char* message, const char* event, uint32_t id, uint32_t reconnect) {
+  String ev = generateEventMessage(message, event, id, reconnect);
+#ifdef ESP32
+  std::lock_guard<std::mutex> lock(_client_queue_lock);
+#endif
+  for (const auto& c : _clients) {
+    if (c->connected()) {
+      c->write(ev.c_str(), ev.length());
+    }
+  }
+}
+
+size_t AsyncEventSource::count() const {
+#ifdef ESP32
+  std::lock_guard<std::mutex> lock(_client_queue_lock);
+#endif
+  size_t n_clients{0};
+  for (const auto& i : _clients)
+    if (i->connected())
+      ++n_clients;
+
+  return n_clients;
+}
+
+bool AsyncEventSource::canHandle(AsyncWebServerRequest* request) {
+  if (request->method() != HTTP_GET || !request->url().equals(_url)) {
+    return false;
+  }
+  request->addInterestingHeader(T_Last_Event_ID);
+  request->addInterestingHeader(T_Cookie);
+  return true;
+}
+
+void AsyncEventSource::handleRequest(AsyncWebServerRequest* request) {
+  if ((_username.length() && _password.length()) && !request->authenticate(_username.c_str(), _password.c_str())) {
+    return request->requestAuthentication();
+  }
+  if (_authorizeConnectHandler != NULL) {
+    if (!_authorizeConnectHandler(request)) {
+      return request->send(401);
+    }
+  }
+  request->send(new AsyncEventSourceResponse(this));
+}
+
+// Response
+
+AsyncEventSourceResponse::AsyncEventSourceResponse(AsyncEventSource* server) {
+  _server = server;
+  _code = 200;
+  _contentType = T_text_event_stream;
+  _sendContentLength = false;
+  addHeader(T_Cache_Control, T_no_cache);
+  addHeader(T_Connection, T_keep_alive);
+}
+
+void AsyncEventSourceResponse::_respond(AsyncWebServerRequest* request) {
+  String out = _assembleHead(request->version());
+  request->client()->write(out.c_str(), _headLength);
+  _state = RESPONSE_WAIT_ACK;
+}
+
+size_t AsyncEventSourceResponse::_ack(AsyncWebServerRequest* request, size_t len, uint32_t time __attribute__((unused))) {
+  if (len) {
+    new AsyncEventSourceClient(request, _server);
+  }
+  return 0;
+}

lib/ESPAsyncWebServer/src/AsyncEventSource.h

@@ -0,0 +1,158 @@
+/*
+  Asynchronous WebServer library for Espressif MCUs
+
+  Copyright (c) 2016 Hristo Gochkov. All rights 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 ASYNCEVENTSOURCE_H_
+#define ASYNCEVENTSOURCE_H_
+
+#include <Arduino.h>
+#include <list>
+#ifdef ESP32
+  #include <AsyncTCP.h>
+  #include <mutex>
+  #ifndef SSE_MAX_QUEUED_MESSAGES
+    #define SSE_MAX_QUEUED_MESSAGES 32
+  #endif
+#elif defined(ESP8266)
+  #include <ESPAsyncTCP.h>
+  #ifndef SSE_MAX_QUEUED_MESSAGES
+    #define SSE_MAX_QUEUED_MESSAGES 8
+  #endif
+#elif defined(TARGET_RP2040)
+  #include <AsyncTCP_RP2040W.h>
+  #ifndef SSE_MAX_QUEUED_MESSAGES
+    #define SSE_MAX_QUEUED_MESSAGES 32
+  #endif
+#endif
+
+#include <ESPAsyncWebServer.h>
+
+#ifdef ESP8266
+  #include <Hash.h>
+  #ifdef CRYPTO_HASH_h // include Hash.h from espressif framework if the first include was from the crypto library
+    #include <../src/Hash.h>
+  #endif
+#endif
+
+#ifndef DEFAULT_MAX_SSE_CLIENTS
+  #ifdef ESP32
+    #define DEFAULT_MAX_SSE_CLIENTS 8
+  #else
+    #define DEFAULT_MAX_SSE_CLIENTS 4
+  #endif
+#endif
+
+class AsyncEventSource;
+class AsyncEventSourceResponse;
+class AsyncEventSourceClient;
+using ArEventHandlerFunction = std::function<void(AsyncEventSourceClient* client)>;
+using ArAuthorizeConnectHandler = std::function<bool(AsyncWebServerRequest* request)>;
+
+class AsyncEventSourceMessage {
+  private:
+    uint8_t* _data;
+    size_t _len;
+    size_t _sent;
+    // size_t _ack;
+    size_t _acked;
+
+  public:
+    AsyncEventSourceMessage(const char* data, size_t len);
+    ~AsyncEventSourceMessage();
+    size_t ack(size_t len, uint32_t time __attribute__((unused)));
+    size_t send(AsyncClient* client);
+    bool finished() { return _acked == _len; }
+    bool sent() { return _sent == _len; }
+};
+
+class AsyncEventSourceClient {
+  private:
+    AsyncClient* _client;
+    AsyncEventSource* _server;
+    uint32_t _lastId;
+    std::list<AsyncEventSourceMessage> _messageQueue;
+#ifdef ESP32
+    mutable std::mutex _lockmq;
+#endif
+    void _queueMessage(const char* message, size_t len);
+    void _runQueue();
+
+  public:
+    AsyncEventSourceClient(AsyncWebServerRequest* request, AsyncEventSource* server);
+    ~AsyncEventSourceClient();
+
+    AsyncClient* client() { return _client; }
+    void close();
+    void write(const char* message, size_t len);
+    void send(const char* message, const char* event = NULL, uint32_t id = 0, uint32_t reconnect = 0);
+    bool connected() const { return (_client != NULL) && _client->connected(); }
+    uint32_t lastId() const { return _lastId; }
+    size_t packetsWaiting() const;
+
+    // system callbacks (do not call)
+    void _onAck(size_t len, uint32_t time);
+    void _onPoll();
+    void _onTimeout(uint32_t time);
+    void _onDisconnect();
+};
+
+class AsyncEventSource : public AsyncWebHandler {
+  private:
+    String _url;
+    std::list<std::unique_ptr<AsyncEventSourceClient>> _clients;
+#ifdef ESP32
+    // Same as for individual messages, protect mutations of _clients list
+    // since simultaneous access from different tasks is possible
+    mutable std::mutex _client_queue_lock;
+#endif
+    ArEventHandlerFunction _connectcb{nullptr};
+    ArAuthorizeConnectHandler _authorizeConnectHandler;
+
+  public:
+    AsyncEventSource(const String& url) : _url(url){};
+    ~AsyncEventSource() { close(); };
+
+    const char* url() const { return _url.c_str(); }
+    void close();
+    void onConnect(ArEventHandlerFunction cb);
+    void authorizeConnect(ArAuthorizeConnectHandler cb);
+    void send(const char* message, const char* event = NULL, uint32_t id = 0, uint32_t reconnect = 0);
+    // number of clients connected
+    size_t count() const;
+    size_t avgPacketsWaiting() const;
+
+    // system callbacks (do not call)
+    void _addClient(AsyncEventSourceClient* client);
+    void _handleDisconnect(AsyncEventSourceClient* client);
+    virtual bool canHandle(AsyncWebServerRequest* request) override final;
+    virtual void handleRequest(AsyncWebServerRequest* request) override final;
+};
+
+class AsyncEventSourceResponse : public AsyncWebServerResponse {
+  private:
+    String _content;
+    AsyncEventSource* _server;
+
+  public:
+    AsyncEventSourceResponse(AsyncEventSource* server);
+    void _respond(AsyncWebServerRequest* request);
+    size_t _ack(AsyncWebServerRequest* request, size_t len, uint32_t time);
+    bool _sourceValid() const { return true; }
+};
+
+#endif /* ASYNCEVENTSOURCE_H_ */

lib/ESPAsyncWebServer/src/AsyncJson.h

@@ -0,0 +1,255 @@
+// AsyncJson.h
+/*
+  Async Response to use with ArduinoJson and AsyncWebServer
+  Written by Andrew Melvin (SticilFace) with help from me-no-dev and BBlanchon.
+
+  Example of callback in use
+
+   server.on("/json", HTTP_ANY, [](AsyncWebServerRequest * request) {
+
+    AsyncJsonResponse * response = new AsyncJsonResponse();
+    JsonObject& root = response->getRoot();
+    root["key1"] = "key number one";
+    JsonObject& nested = root.createNestedObject("nested");
+    nested["key1"] = "key number one";
+
+    response->setLength();
+    request->send(response);
+  });
+
+  --------------------
+
+  Async Request to use with ArduinoJson and AsyncWebServer
+  Written by Arsène von Wyss (avonwyss)
+
+  Example
+
+  AsyncCallbackJsonWebHandler* handler = new AsyncCallbackJsonWebHandler("/rest/endpoint");
+  handler->onRequest([](AsyncWebServerRequest *request, JsonVariant &json) {
+    JsonObject jsonObj = json.as<JsonObject>();
+    // ...
+  });
+  server.addHandler(handler);
+
+*/
+#ifndef ASYNC_JSON_H_
+#define ASYNC_JSON_H_
+#include <ArduinoJson.h>
+#include <ESPAsyncWebServer.h>
+
+#include "ChunkPrint.h"
+
+#if ARDUINOJSON_VERSION_MAJOR == 6
+  #ifndef DYNAMIC_JSON_DOCUMENT_SIZE
+    #define DYNAMIC_JSON_DOCUMENT_SIZE 1024
+  #endif
+#endif
+
+constexpr const char* JSON_MIMETYPE = "application/json";
+
+/*
+ * Json Response
+ * */
+
+class AsyncJsonResponse : public AsyncAbstractResponse {
+  protected:
+#if ARDUINOJSON_VERSION_MAJOR == 5
+    DynamicJsonBuffer _jsonBuffer;
+#elif ARDUINOJSON_VERSION_MAJOR == 6
+    DynamicJsonDocument _jsonBuffer;
+#else
+    JsonDocument _jsonBuffer;
+#endif
+
+    JsonVariant _root;
+    bool _isValid;
+
+  public:
+#if ARDUINOJSON_VERSION_MAJOR == 5
+    AsyncJsonResponse(bool isArray = false) : _isValid{false} {
+      _code = 200;
+      _contentType = JSON_MIMETYPE;
+      if (isArray)
+        _root = _jsonBuffer.createArray();
+      else
+        _root = _jsonBuffer.createObject();
+    }
+#elif ARDUINOJSON_VERSION_MAJOR == 6
+    AsyncJsonResponse(bool isArray = false, size_t maxJsonBufferSize = DYNAMIC_JSON_DOCUMENT_SIZE) : _jsonBuffer(maxJsonBufferSize), _isValid{false} {
+      _code = 200;
+      _contentType = JSON_MIMETYPE;
+      if (isArray)
+        _root = _jsonBuffer.createNestedArray();
+      else
+        _root = _jsonBuffer.createNestedObject();
+    }
+#else
+    AsyncJsonResponse(bool isArray = false) : _isValid{false} {
+      _code = 200;
+      _contentType = JSON_MIMETYPE;
+      if (isArray)
+        _root = _jsonBuffer.add<JsonArray>();
+      else
+        _root = _jsonBuffer.add<JsonObject>();
+    }
+#endif
+
+    JsonVariant& getRoot() { return _root; }
+    bool _sourceValid() const { return _isValid; }
+    size_t setLength() {
+
+#if ARDUINOJSON_VERSION_MAJOR == 5
+      _contentLength = _root.measureLength();
+#else
+      _contentLength = measureJson(_root);
+#endif
+
+      if (_contentLength) {
+        _isValid = true;
+      }
+      return _contentLength;
+    }
+
+    size_t getSize() const { return _jsonBuffer.size(); }
+
+#if ARDUINOJSON_VERSION_MAJOR >= 6
+    bool overflowed() const { return _jsonBuffer.overflowed(); }
+#endif
+
+    size_t _fillBuffer(uint8_t* data, size_t len) {
+      ChunkPrint dest(data, _sentLength, len);
+
+#if ARDUINOJSON_VERSION_MAJOR == 5
+      _root.printTo(dest);
+#else
+      serializeJson(_root, dest);
+#endif
+      return len;
+    }
+};
+
+class PrettyAsyncJsonResponse : public AsyncJsonResponse {
+  public:
+#if ARDUINOJSON_VERSION_MAJOR == 6
+    PrettyAsyncJsonResponse(bool isArray = false, size_t maxJsonBufferSize = DYNAMIC_JSON_DOCUMENT_SIZE) : AsyncJsonResponse{isArray, maxJsonBufferSize} {}
+#else
+    PrettyAsyncJsonResponse(bool isArray = false) : AsyncJsonResponse{isArray} {}
+#endif
+    size_t setLength() {
+#if ARDUINOJSON_VERSION_MAJOR == 5
+      _contentLength = _root.measurePrettyLength();
+#else
+      _contentLength = measureJsonPretty(_root);
+#endif
+      if (_contentLength) {
+        _isValid = true;
+      }
+      return _contentLength;
+    }
+    size_t _fillBuffer(uint8_t* data, size_t len) {
+      ChunkPrint dest(data, _sentLength, len);
+#if ARDUINOJSON_VERSION_MAJOR == 5
+      _root.prettyPrintTo(dest);
+#else
+      serializeJsonPretty(_root, dest);
+#endif
+      return len;
+    }
+};
+
+typedef std::function<void(AsyncWebServerRequest* request, JsonVariant& json)> ArJsonRequestHandlerFunction;
+
+class AsyncCallbackJsonWebHandler : public AsyncWebHandler {
+  private:
+  protected:
+    const String _uri;
+    WebRequestMethodComposite _method;
+    ArJsonRequestHandlerFunction _onRequest;
+    size_t _contentLength;
+#if ARDUINOJSON_VERSION_MAJOR == 6
+    const size_t maxJsonBufferSize;
+#endif
+    size_t _maxContentLength;
+
+  public:
+#if ARDUINOJSON_VERSION_MAJOR == 6
+    AsyncCallbackJsonWebHandler(const String& uri, ArJsonRequestHandlerFunction onRequest = nullptr, size_t maxJsonBufferSize = DYNAMIC_JSON_DOCUMENT_SIZE)
+        : _uri(uri), _method(HTTP_GET | HTTP_POST | HTTP_PUT | HTTP_PATCH), _onRequest(onRequest), maxJsonBufferSize(maxJsonBufferSize), _maxContentLength(16384) {}
+#else
+    AsyncCallbackJsonWebHandler(const String& uri, ArJsonRequestHandlerFunction onRequest = nullptr)
+        : _uri(uri), _method(HTTP_GET | HTTP_POST | HTTP_PUT | HTTP_PATCH), _onRequest(onRequest), _maxContentLength(16384) {}
+#endif
+
+    void setMethod(WebRequestMethodComposite method) { _method = method; }
+    void setMaxContentLength(int maxContentLength) { _maxContentLength = maxContentLength; }
+    void onRequest(ArJsonRequestHandlerFunction fn) { _onRequest = fn; }
+
+    virtual bool canHandle(AsyncWebServerRequest* request) override final {
+      if (!_onRequest)
+        return false;
+
+      WebRequestMethodComposite request_method = request->method();
+      if (!(_method & request_method))
+        return false;
+
+      if (_uri.length() && (_uri != request->url() && !request->url().startsWith(_uri + "/")))
+        return false;
+
+      if (request_method != HTTP_GET && !request->contentType().equalsIgnoreCase(JSON_MIMETYPE))
+        return false;
+
+      request->addInterestingHeader("ANY");
+      return true;
+    }
+
+    virtual void handleRequest(AsyncWebServerRequest* request) override final {
+      if ((_username != "" && _password != "") && !request->authenticate(_username.c_str(), _password.c_str()))
+        return request->requestAuthentication();
+      if (_onRequest) {
+        if (request->method() == HTTP_GET) {
+          JsonVariant json;
+          _onRequest(request, json);
+          return;
+        } else if (request->_tempObject != NULL) {
+
+#if ARDUINOJSON_VERSION_MAJOR == 5
+          DynamicJsonBuffer jsonBuffer;
+          JsonVariant json = jsonBuffer.parse((uint8_t*)(request->_tempObject));
+          if (json.success()) {
+#elif ARDUINOJSON_VERSION_MAJOR == 6
+          DynamicJsonDocument jsonBuffer(this->maxJsonBufferSize);
+          DeserializationError error = deserializeJson(jsonBuffer, (uint8_t*)(request->_tempObject));
+          if (!error) {
+            JsonVariant json = jsonBuffer.as<JsonVariant>();
+#else
+          JsonDocument jsonBuffer;
+          DeserializationError error = deserializeJson(jsonBuffer, (uint8_t*)(request->_tempObject));
+          if (!error) {
+            JsonVariant json = jsonBuffer.as<JsonVariant>();
+#endif
+
+            _onRequest(request, json);
+            return;
+          }
+        }
+        request->send(_contentLength > _maxContentLength ? 413 : 400);
+      } else {
+        request->send(500);
+      }
+    }
+    virtual void handleUpload(__unused AsyncWebServerRequest* request, __unused const String& filename, __unused size_t index, __unused uint8_t* data, __unused size_t len, __unused bool final) override final {
+    }
+    virtual void handleBody(AsyncWebServerRequest* request, uint8_t* data, size_t len, size_t index, size_t total) override final {
+      if (_onRequest) {
+        _contentLength = total;
+        if (total > 0 && request->_tempObject == NULL && total < _maxContentLength) {
+          request->_tempObject = malloc(total);
+        }
+        if (request->_tempObject != NULL) {
+          memcpy((uint8_t*)(request->_tempObject) + index, data, len);
+        }
+      }
+    }
+    virtual bool isRequestHandlerTrivial() override final { return _onRequest ? false : true; }
+};
+#endif

lib/ESPAsyncWebServer/src/AsyncMessagePack.h

@@ -0,0 +1,145 @@
+#pragma once
+
+/*
+   server.on("/msg_pack", HTTP_ANY, [](AsyncWebServerRequest * request) {
+    AsyncMessagePackResponse * response = new AsyncMessagePackResponse();
+    JsonObject& root = response->getRoot();
+    root["key1"] = "key number one";
+    JsonObject& nested = root.createNestedObject("nested");
+    nested["key1"] = "key number one";
+    response->setLength();
+    request->send(response);
+  });
+
+  --------------------
+
+  AsyncCallbackMessagePackWebHandler* handler = new AsyncCallbackMessagePackWebHandler("/msg_pack/endpoint");
+  handler->onRequest([](AsyncWebServerRequest *request, JsonVariant &json) {
+    JsonObject jsonObj = json.as<JsonObject>();
+    // ...
+  });
+  server.addHandler(handler);
+*/
+
+#include <ArduinoJson.h>
+#include <ESPAsyncWebServer.h>
+
+#include "ChunkPrint.h"
+#include "literals.h"
+
+class AsyncMessagePackResponse : public AsyncAbstractResponse {
+  protected:
+    JsonDocument _jsonBuffer;
+    JsonVariant _root;
+    bool _isValid;
+
+  public:
+    AsyncMessagePackResponse(bool isArray = false) : _isValid{false} {
+      _code = 200;
+      _contentType = asyncsrv::T_application_msgpack;
+      if (isArray)
+        _root = _jsonBuffer.add<JsonArray>();
+      else
+        _root = _jsonBuffer.add<JsonObject>();
+    }
+
+    JsonVariant& getRoot() { return _root; }
+
+    bool _sourceValid() const { return _isValid; }
+
+    size_t setLength() {
+      _contentLength = measureMsgPack(_root);
+      if (_contentLength) {
+        _isValid = true;
+      }
+      return _contentLength;
+    }
+
+    size_t getSize() const { return _jsonBuffer.size(); }
+
+    size_t _fillBuffer(uint8_t* data, size_t len) {
+      ChunkPrint dest(data, _sentLength, len);
+      serializeMsgPack(_root, dest);
+      return len;
+    }
+};
+
+class AsyncCallbackMessagePackWebHandler : public AsyncWebHandler {
+  public:
+    typedef std::function<void(AsyncWebServerRequest* request, JsonVariant& json)> ArJsonRequestHandlerFunction;
+
+  protected:
+    const String _uri;
+    WebRequestMethodComposite _method;
+    ArJsonRequestHandlerFunction _onRequest;
+    size_t _contentLength;
+    size_t _maxContentLength;
+
+  public:
+    AsyncCallbackMessagePackWebHandler(const String& uri, ArJsonRequestHandlerFunction onRequest = nullptr)
+        : _uri(uri), _method(HTTP_GET | HTTP_POST | HTTP_PUT | HTTP_PATCH), _onRequest(onRequest), _maxContentLength(16384) {}
+
+    void setMethod(WebRequestMethodComposite method) { _method = method; }
+    void setMaxContentLength(int maxContentLength) { _maxContentLength = maxContentLength; }
+    void onRequest(ArJsonRequestHandlerFunction fn) { _onRequest = fn; }
+
+    virtual bool canHandle(AsyncWebServerRequest* request) override final {
+      if (!_onRequest)
+        return false;
+
+      WebRequestMethodComposite request_method = request->method();
+      if (!(_method & request_method))
+        return false;
+
+      if (_uri.length() && (_uri != request->url() && !request->url().startsWith(_uri + "/")))
+        return false;
+
+      if (request_method != HTTP_GET && !request->contentType().equalsIgnoreCase(asyncsrv::T_application_msgpack))
+        return false;
+
+      request->addInterestingHeader("ANY");
+      return true;
+    }
+
+    virtual void handleRequest(AsyncWebServerRequest* request) override final {
+      if ((_username != "" && _password != "") && !request->authenticate(_username.c_str(), _password.c_str()))
+        return request->requestAuthentication();
+
+      if (_onRequest) {
+        if (request->method() == HTTP_GET) {
+          JsonVariant json;
+          _onRequest(request, json);
+          return;
+
+        } else if (request->_tempObject != NULL) {
+          JsonDocument jsonBuffer;
+          DeserializationError error = deserializeMsgPack(jsonBuffer, (uint8_t*)(request->_tempObject));
+
+          if (!error) {
+            JsonVariant json = jsonBuffer.as<JsonVariant>();
+            _onRequest(request, json);
+            return;
+          }
+        }
+        request->send(_contentLength > _maxContentLength ? 413 : 400);
+      } else {
+        request->send(500);
+      }
+    }
+
+    virtual void handleUpload(__unused AsyncWebServerRequest* request, __unused const String& filename, __unused size_t index, __unused uint8_t* data, __unused size_t len, __unused bool final) override final {}
+
+    virtual void handleBody(AsyncWebServerRequest* request, uint8_t* data, size_t len, size_t index, size_t total) override final {
+      if (_onRequest) {
+        _contentLength = total;
+        if (total > 0 && request->_tempObject == NULL && total < _maxContentLength) {
+          request->_tempObject = malloc(total);
+        }
+        if (request->_tempObject != NULL) {
+          memcpy((uint8_t*)(request->_tempObject) + index, data, len);
+        }
+      }
+    }
+
+    virtual bool isRequestHandlerTrivial() override final { return _onRequest ? false : true; }
+};

lib/ESPAsyncWebServer/src/AsyncWebSocket.h

@@ -0,0 +1,379 @@
+/*
+  Asynchronous WebServer 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 ASYNCWEBSOCKET_H_
+#define ASYNCWEBSOCKET_H_
+
+#include <Arduino.h>
+#ifdef ESP32
+  #include <AsyncTCP.h>
+  #include <mutex>
+  #ifndef WS_MAX_QUEUED_MESSAGES
+    #define WS_MAX_QUEUED_MESSAGES 32
+  #endif
+#elif defined(ESP8266)
+  #include <ESPAsyncTCP.h>
+  #ifndef WS_MAX_QUEUED_MESSAGES
+    #define WS_MAX_QUEUED_MESSAGES 8
+  #endif
+#elif defined(TARGET_RP2040)
+  #include <AsyncTCP_RP2040W.h>
+  #ifndef WS_MAX_QUEUED_MESSAGES
+    #define WS_MAX_QUEUED_MESSAGES 32
+  #endif
+#endif
+
+#include <ESPAsyncWebServer.h>
+
+#include <deque>
+#include <list>
+#include <memory>
+
+#ifdef ESP8266
+  #include <Hash.h>
+  #ifdef CRYPTO_HASH_h // include Hash.h from espressif framework if the first include was from the crypto library
+    #include <../src/Hash.h>
+  #endif
+#endif
+
+#ifndef DEFAULT_MAX_WS_CLIENTS
+  #ifdef ESP32
+    #define DEFAULT_MAX_WS_CLIENTS 8
+  #else
+    #define DEFAULT_MAX_WS_CLIENTS 4
+  #endif
+#endif
+
+using AsyncWebSocketSharedBuffer = std::shared_ptr<std::vector<uint8_t>>;
+
+class AsyncWebSocket;
+class AsyncWebSocketResponse;
+class AsyncWebSocketClient;
+class AsyncWebSocketControl;
+
+typedef struct {
+    /** Message type as defined by enum AwsFrameType.
+     * Note: Applications will only see WS_TEXT and WS_BINARY.
+     * All other types are handled by the library. */
+    uint8_t message_opcode;
+    /** Frame number of a fragmented message. */
+    uint32_t num;
+    /** Is this the last frame in a fragmented message ?*/
+    uint8_t final;
+    /** Is this frame masked? */
+    uint8_t masked;
+    /** Message type as defined by enum AwsFrameType.
+     * This value is the same as message_opcode for non-fragmented
+     * messages, but may also be WS_CONTINUATION in a fragmented message. */
+    uint8_t opcode;
+    /** Length of the current frame.
+     * This equals the total length of the message if num == 0 && final == true */
+    uint64_t len;
+    /** Mask key */
+    uint8_t mask[4];
+    /** Offset of the data inside the current frame. */
+    uint64_t index;
+} AwsFrameInfo;
+
+typedef enum { WS_DISCONNECTED,
+               WS_CONNECTED,
+               WS_DISCONNECTING } AwsClientStatus;
+typedef enum { WS_CONTINUATION,
+               WS_TEXT,
+               WS_BINARY,
+               WS_DISCONNECT = 0x08,
+               WS_PING,
+               WS_PONG } AwsFrameType;
+typedef enum { WS_MSG_SENDING,
+               WS_MSG_SENT,
+               WS_MSG_ERROR } AwsMessageStatus;
+typedef enum { WS_EVT_CONNECT,
+               WS_EVT_DISCONNECT,
+               WS_EVT_PONG,
+               WS_EVT_ERROR,
+               WS_EVT_DATA } AwsEventType;
+
+class AsyncWebSocketMessageBuffer {
+    friend AsyncWebSocket;
+    friend AsyncWebSocketClient;
+
+  private:
+    AsyncWebSocketSharedBuffer _buffer;
+
+  public:
+    AsyncWebSocketMessageBuffer() {}
+    explicit AsyncWebSocketMessageBuffer(size_t size);
+    AsyncWebSocketMessageBuffer(const uint8_t* data, size_t size);
+    //~AsyncWebSocketMessageBuffer();
+    bool reserve(size_t size);
+    uint8_t* get() { return _buffer->data(); }
+    size_t length() const { return _buffer->size(); }
+};
+
+class AsyncWebSocketMessage {
+  private:
+    AsyncWebSocketSharedBuffer _WSbuffer;
+    uint8_t _opcode{WS_TEXT};
+    bool _mask{false};
+    AwsMessageStatus _status{WS_MSG_ERROR};
+    size_t _sent{};
+    size_t _ack{};
+    size_t _acked{};
+
+  public:
+    AsyncWebSocketMessage(AsyncWebSocketSharedBuffer buffer, uint8_t opcode = WS_TEXT, bool mask = false);
+
+    bool finished() const { return _status != WS_MSG_SENDING; }
+    bool betweenFrames() const { return _acked == _ack; }
+
+    void ack(size_t len, uint32_t time);
+    size_t send(AsyncClient* client);
+};
+
+class AsyncWebSocketClient {
+  private:
+    AsyncClient* _client;
+    AsyncWebSocket* _server;
+    uint32_t _clientId;
+    AwsClientStatus _status;
+#ifdef ESP32
+    mutable std::mutex _lock;
+#endif
+    std::deque<AsyncWebSocketControl> _controlQueue;
+    std::deque<AsyncWebSocketMessage> _messageQueue;
+    bool closeWhenFull = true;
+
+    uint8_t _pstate;
+    AwsFrameInfo _pinfo;
+
+    uint32_t _lastMessageTime;
+    uint32_t _keepAlivePeriod;
+
+    void _queueControl(uint8_t opcode, const uint8_t* data = NULL, size_t len = 0, bool mask = false);
+    void _queueMessage(AsyncWebSocketSharedBuffer buffer, uint8_t opcode = WS_TEXT, bool mask = false);
+    void _runQueue();
+    void _clearQueue();
+
+  public:
+    void* _tempObject;
+
+    AsyncWebSocketClient(AsyncWebServerRequest* request, AsyncWebSocket* server);
+    ~AsyncWebSocketClient();
+
+    // client id increments for the given server
+    uint32_t id() const { return _clientId; }
+    AwsClientStatus status() const { return _status; }
+    AsyncClient* client() { return _client; }
+    const AsyncClient* client() const { return _client; }
+    AsyncWebSocket* server() { return _server; }
+    const AsyncWebSocket* server() const { return _server; }
+    AwsFrameInfo const& pinfo() const { return _pinfo; }
+
+    //  - If "true" (default), the connection will be closed if the message queue is full.
+    // This is the default behavior in yubox-node-org, which is not silently discarding messages but instead closes the connection.
+    // The big issue with this behavior is  that is can cause the UI to automatically re-create a new WS connection, which can be filled again,
+    // and so on, causing a resource exhaustion.
+    //
+    // - If "false", the incoming message will be discarded if the queue is full.
+    // This is the default behavior in the original ESPAsyncWebServer library from me-no-dev.
+    // This behavior allows the best performance at the expense of unreliable message delivery in case the queue is full (some messages may be lost).
+    //
+    // - In any case, when the queue is full, a message is logged.
+    // - IT is recommended to use the methods queueIsFull(), availableForWriteAll(), availableForWrite(clientId) to check if the queue is full before sending a message.
+    //
+    // Usage:
+    //  - can be set in the onEvent listener when connecting (event type is: WS_EVT_CONNECT)
+    //
+    // Use cases:,
+    // - if using websocket to send logging messages, maybe some loss is acceptable.
+    // - But if using websocket to send UI update messages, maybe the connection should be closed and the UI redrawn.
+    void setCloseClientOnQueueFull(bool close) { closeWhenFull = close; }
+    bool willCloseClientOnQueueFull() const { return closeWhenFull; }
+
+    IPAddress remoteIP() const;
+    uint16_t remotePort() const;
+
+    bool shouldBeDeleted() const { return !_client; }
+
+    // control frames
+    void close(uint16_t code = 0, const char* message = NULL);
+    void ping(const uint8_t* data = NULL, size_t len = 0);
+
+    // set auto-ping period in seconds. disabled if zero (default)
+    void keepAlivePeriod(uint16_t seconds) {
+      _keepAlivePeriod = seconds * 1000;
+    }
+    uint16_t keepAlivePeriod() {
+      return (uint16_t)(_keepAlivePeriod / 1000);
+    }
+
+    // data packets
+    void message(AsyncWebSocketSharedBuffer buffer, uint8_t opcode = WS_TEXT, bool mask = false) { _queueMessage(buffer, opcode, mask); }
+    bool queueIsFull() const;
+    size_t queueLen() const;
+
+    size_t printf(const char* format, ...) __attribute__((format(printf, 2, 3)));
+
+    void text(AsyncWebSocketSharedBuffer buffer);
+    void text(const uint8_t* message, size_t len);
+    void text(const char* message, size_t len);
+    void text(const char* message);
+    void text(const String& message);
+    void text(AsyncWebSocketMessageBuffer* buffer);
+
+    void binary(AsyncWebSocketSharedBuffer buffer);
+    void binary(const uint8_t* message, size_t len);
+    void binary(const char* message, size_t len);
+    void binary(const char* message);
+    void binary(const String& message);
+    void binary(AsyncWebSocketMessageBuffer* buffer);
+
+    bool canSend() const;
+
+    // system callbacks (do not call)
+    void _onAck(size_t len, uint32_t time);
+    void _onError(int8_t);
+    void _onPoll();
+    void _onTimeout(uint32_t time);
+    void _onDisconnect();
+    void _onData(void* pbuf, size_t plen);
+
+#ifdef ESP8266
+    size_t printf_P(PGM_P formatP, ...) __attribute__((format(printf, 2, 3)));
+    void text(const __FlashStringHelper* message);
+    void binary(const __FlashStringHelper* message, size_t len);
+#endif
+};
+
+using AwsHandshakeHandler = std::function<bool(AsyncWebServerRequest* request)>;
+using AwsEventHandler = std::function<void(AsyncWebSocket* server, AsyncWebSocketClient* client, AwsEventType type, void* arg, uint8_t* data, size_t len)>;
+
+// WebServer Handler implementation that plays the role of a socket server
+class AsyncWebSocket : public AsyncWebHandler {
+  private:
+    String _url;
+    std::list<AsyncWebSocketClient> _clients;
+    uint32_t _cNextId;
+    AwsEventHandler _eventHandler{nullptr};
+    AwsHandshakeHandler _handshakeHandler;
+    bool _enabled;
+#ifdef ESP32
+    mutable std::mutex _lock;
+#endif
+
+  public:
+    explicit AsyncWebSocket(const char* url) : _url(url), _cNextId(1), _enabled(true) {}
+    AsyncWebSocket(const String& url) : _url(url), _cNextId(1), _enabled(true) {}
+    ~AsyncWebSocket(){};
+    const char* url() const { return _url.c_str(); }
+    void enable(bool e) { _enabled = e; }
+    bool enabled() const { return _enabled; }
+    bool availableForWriteAll();
+    bool availableForWrite(uint32_t id);
+
+    size_t count() const;
+    AsyncWebSocketClient* client(uint32_t id);
+    bool hasClient(uint32_t id) { return client(id) != nullptr; }
+
+    void close(uint32_t id, uint16_t code = 0, const char* message = NULL);
+    void closeAll(uint16_t code = 0, const char* message = NULL);
+    void cleanupClients(uint16_t maxClients = DEFAULT_MAX_WS_CLIENTS);
+
+    void ping(uint32_t id, const uint8_t* data = NULL, size_t len = 0);
+    void pingAll(const uint8_t* data = NULL, size_t len = 0); //  done
+
+    void text(uint32_t id, const uint8_t* message, size_t len);
+    void text(uint32_t id, const char* message, size_t len);
+    void text(uint32_t id, const char* message);
+    void text(uint32_t id, const String& message);
+    void text(uint32_t id, AsyncWebSocketMessageBuffer* buffer);
+    void text(uint32_t id, AsyncWebSocketSharedBuffer buffer);
+
+    void textAll(const uint8_t* message, size_t len);
+    void textAll(const char* message, size_t len);
+    void textAll(const char* message);
+    void textAll(const String& message);
+    void textAll(AsyncWebSocketMessageBuffer* buffer);
+    void textAll(AsyncWebSocketSharedBuffer buffer);
+
+    void binary(uint32_t id, const uint8_t* message, size_t len);
+    void binary(uint32_t id, const char* message, size_t len);
+    void binary(uint32_t id, const char* message);
+    void binary(uint32_t id, const String& message);
+    void binary(uint32_t id, AsyncWebSocketMessageBuffer* buffer);
+    void binary(uint32_t id, AsyncWebSocketSharedBuffer buffer);
+
+    void binaryAll(const uint8_t* message, size_t len);
+    void binaryAll(const char* message, size_t len);
+    void binaryAll(const char* message);
+    void binaryAll(const String& message);
+    void binaryAll(AsyncWebSocketMessageBuffer* buffer);
+    void binaryAll(AsyncWebSocketSharedBuffer buffer);
+
+    size_t printf(uint32_t id, const char* format, ...) __attribute__((format(printf, 3, 4)));
+    size_t printfAll(const char* format, ...) __attribute__((format(printf, 2, 3)));
+
+#ifdef ESP8266
+    void text(uint32_t id, const __FlashStringHelper* message);
+    void textAll(const __FlashStringHelper* message);
+    void binary(uint32_t id, const __FlashStringHelper* message, size_t len);
+    void binaryAll(const __FlashStringHelper* message, size_t len);
+    size_t printf_P(uint32_t id, PGM_P formatP, ...) __attribute__((format(printf, 3, 4)));
+    size_t printfAll_P(PGM_P formatP, ...) __attribute__((format(printf, 2, 3)));
+#endif
+
+    // event listener
+    void onEvent(AwsEventHandler handler) {
+      _eventHandler = handler;
+    }
+
+    // Handshake Handler
+    void handleHandshake(AwsHandshakeHandler handler) {
+      _handshakeHandler = handler;
+    }
+
+    // system callbacks (do not call)
+    uint32_t _getNextId() { return _cNextId++; }
+    AsyncWebSocketClient* _newClient(AsyncWebServerRequest* request);
+    void _handleEvent(AsyncWebSocketClient* client, AwsEventType type, void* arg, uint8_t* data, size_t len);
+    virtual bool canHandle(AsyncWebServerRequest* request) override final;
+    virtual void handleRequest(AsyncWebServerRequest* request) override final;
+
+    //  messagebuffer functions/objects.
+    AsyncWebSocketMessageBuffer* makeBuffer(size_t size = 0);
+    AsyncWebSocketMessageBuffer* makeBuffer(const uint8_t* data, size_t size);
+
+    const std::list<AsyncWebSocketClient>& getClients() const { return _clients; }
+};
+
+// WebServer response to authenticate the socket and detach the tcp client from the web server request
+class AsyncWebSocketResponse : public AsyncWebServerResponse {
+  private:
+    String _content;
+    AsyncWebSocket* _server;
+
+  public:
+    AsyncWebSocketResponse(const String& key, AsyncWebSocket* server);
+    void _respond(AsyncWebServerRequest* request);
+    size_t _ack(AsyncWebServerRequest* request, size_t len, uint32_t time);
+    bool _sourceValid() const { return true; }
+};
+
+#endif /* ASYNCWEBSOCKET_H_ */

lib/ESPAsyncWebServer/src/ChunkPrint.h

@@ -0,0 +1,32 @@
+#ifndef CHUNKPRINT_H
+#define CHUNKPRINT_H
+
+#include <Print.h>
+
+class ChunkPrint : public Print {
+  private:
+    uint8_t* _destination;
+    size_t _to_skip;
+    size_t _to_write;
+    size_t _pos;
+
+  public:
+    ChunkPrint(uint8_t* destination, size_t from, size_t len)
+        : _destination(destination), _to_skip(from), _to_write(len), _pos{0} {}
+    virtual ~ChunkPrint() {}
+    size_t write(uint8_t c) {
+      if (_to_skip > 0) {
+        _to_skip--;
+        return 1;
+      } else if (_to_write > 0) {
+        _to_write--;
+        _destination[_pos++] = c;
+        return 1;
+      }
+      return 0;
+    }
+    size_t write(const uint8_t* buffer, size_t size) {
+      return this->Print::write(buffer, size);
+    }
+};
+#endif

lib/ESPAsyncWebServer/src/ESPAsyncWebServer.h

@@ -0,0 +1,714 @@
+/*
+  Asynchronous WebServer 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 _ESPAsyncWebServer_H_
+#define _ESPAsyncWebServer_H_
+
+#include "Arduino.h"
+
+#include "FS.h"
+#include <functional>
+#include <list>
+#include <vector>
+
+#ifdef ESP32
+  #include <AsyncTCP.h>
+  #include <WiFi.h>
+#elif defined(ESP8266)
+  #include <ESP8266WiFi.h>
+  #include <ESPAsyncTCP.h>
+#elif defined(TARGET_RP2040)
+  #include <AsyncTCP_RP2040W.h>
+  #include <HTTP_Method.h>
+  #include <WiFi.h>
+  #include <http_parser.h>
+#else
+  #error Platform not supported
+#endif
+
+#include "literals.h"
+
+#define ASYNCWEBSERVER_VERSION          "3.1.5"
+#define ASYNCWEBSERVER_VERSION_MAJOR    3
+#define ASYNCWEBSERVER_VERSION_MINOR    1
+#define ASYNCWEBSERVER_VERSION_REVISION 5
+#define ASYNCWEBSERVER_FORK_mathieucarbou
+
+#ifdef ASYNCWEBSERVER_REGEX
+  #define ASYNCWEBSERVER_REGEX_ATTRIBUTE
+#else
+  #define ASYNCWEBSERVER_REGEX_ATTRIBUTE __attribute__((warning("ASYNCWEBSERVER_REGEX not defined")))
+#endif
+
+class AsyncWebServer;
+class AsyncWebServerRequest;
+class AsyncWebServerResponse;
+class AsyncWebHeader;
+class AsyncWebParameter;
+class AsyncWebRewrite;
+class AsyncWebHandler;
+class AsyncStaticWebHandler;
+class AsyncCallbackWebHandler;
+class AsyncResponseStream;
+
+#if defined(TARGET_RP2040)
+typedef enum http_method WebRequestMethod;
+#else
+  #ifndef WEBSERVER_H
+typedef enum {
+  HTTP_GET = 0b00000001,
+  HTTP_POST = 0b00000010,
+  HTTP_DELETE = 0b00000100,
+  HTTP_PUT = 0b00001000,
+  HTTP_PATCH = 0b00010000,
+  HTTP_HEAD = 0b00100000,
+  HTTP_OPTIONS = 0b01000000,
+  HTTP_ANY = 0b01111111,
+} WebRequestMethod;
+  #endif
+#endif
+
+#ifndef HAVE_FS_FILE_OPEN_MODE
+namespace fs {
+  class FileOpenMode {
+    public:
+      static const char* read;
+      static const char* write;
+      static const char* append;
+  };
+};
+#else
+  #include "FileOpenMode.h"
+#endif
+
+// if this value is returned when asked for data, packet will not be sent and you will be asked for data again
+#define RESPONSE_TRY_AGAIN 0xFFFFFFFF
+
+typedef uint8_t WebRequestMethodComposite;
+typedef std::function<void(void)> ArDisconnectHandler;
+
+/*
+ * PARAMETER :: Chainable object to hold GET/POST and FILE parameters
+ * */
+
+class AsyncWebParameter {
+  private:
+    String _name;
+    String _value;
+    size_t _size;
+    bool _isForm;
+    bool _isFile;
+
+  public:
+    AsyncWebParameter(const String& name, const String& value, bool form = false, bool file = false, size_t size = 0) : _name(name), _value(value), _size(size), _isForm(form), _isFile(file) {}
+    const String& name() const { return _name; }
+    const String& value() const { return _value; }
+    size_t size() const { return _size; }
+    bool isPost() const { return _isForm; }
+    bool isFile() const { return _isFile; }
+};
+
+/*
+ * HEADER :: Chainable object to hold the headers
+ * */
+
+class AsyncWebHeader {
+  private:
+    String _name;
+    String _value;
+
+  public:
+    AsyncWebHeader() = default;
+    AsyncWebHeader(const AsyncWebHeader&) = default;
+
+    AsyncWebHeader(const char* name, const char* value) : _name(name), _value(value) {}
+    AsyncWebHeader(const String& name, const String& value) : _name(name), _value(value) {}
+    AsyncWebHeader(const String& data) {
+      if (!data)
+        return;
+      int index = data.indexOf(':');
+      if (index < 0)
+        return;
+      _name = data.substring(0, index);
+      _value = data.substring(index + 2);
+    }
+
+    AsyncWebHeader& operator=(const AsyncWebHeader&) = default;
+
+    const String& name() const { return _name; }
+    const String& value() const { return _value; }
+    String toString() const {
+      String str = _name;
+      str.concat((char)0x3a);
+      str.concat((char)0x20);
+      str.concat(_value);
+      str.concat(asyncsrv::T_rn);
+      return str;
+    }
+};
+
+/*
+ * REQUEST :: Each incoming Client is wrapped inside a Request and both live together until disconnect
+ * */
+
+typedef enum { RCT_NOT_USED = -1,
+               RCT_DEFAULT = 0,
+               RCT_HTTP,
+               RCT_WS,
+               RCT_EVENT,
+               RCT_MAX } RequestedConnectionType;
+
+typedef std::function<size_t(uint8_t*, size_t, size_t)> AwsResponseFiller;
+typedef std::function<String(const String&)> AwsTemplateProcessor;
+
+class AsyncWebServerRequest {
+    using File = fs::File;
+    using FS = fs::FS;
+    friend class AsyncWebServer;
+    friend class AsyncCallbackWebHandler;
+
+  private:
+    AsyncClient* _client;
+    AsyncWebServer* _server;
+    AsyncWebHandler* _handler;
+    AsyncWebServerResponse* _response;
+    std::vector<String> _interestingHeaders;
+    ArDisconnectHandler _onDisconnectfn;
+
+    String _temp;
+    uint8_t _parseState;
+
+    uint8_t _version;
+    WebRequestMethodComposite _method;
+    String _url;
+    String _host;
+    String _contentType;
+    String _boundary;
+    String _authorization;
+    RequestedConnectionType _reqconntype;
+    void _removeNotInterestingHeaders();
+    bool _isDigest;
+    bool _isMultipart;
+    bool _isPlainPost;
+    bool _expectingContinue;
+    size_t _contentLength;
+    size_t _parsedLength;
+
+    std::list<AsyncWebHeader> _headers;
+    std::list<AsyncWebParameter> _params;
+    std::vector<String> _pathParams;
+
+    uint8_t _multiParseState;
+    uint8_t _boundaryPosition;
+    size_t _itemStartIndex;
+    size_t _itemSize;
+    String _itemName;
+    String _itemFilename;
+    String _itemType;
+    String _itemValue;
+    uint8_t* _itemBuffer;
+    size_t _itemBufferIndex;
+    bool _itemIsFile;
+
+    void _onPoll();
+    void _onAck(size_t len, uint32_t time);
+    void _onError(int8_t error);
+    void _onTimeout(uint32_t time);
+    void _onDisconnect();
+    void _onData(void* buf, size_t len);
+
+    void _addPathParam(const char* param);
+
+    bool _parseReqHead();
+    bool _parseReqHeader();
+    void _parseLine();
+    void _parsePlainPostChar(uint8_t data);
+    void _parseMultipartPostByte(uint8_t data, bool last);
+    void _addGetParams(const String& params);
+
+    void _handleUploadStart();
+    void _handleUploadByte(uint8_t data, bool last);
+    void _handleUploadEnd();
+
+  public:
+    File _tempFile;
+    void* _tempObject;
+
+    AsyncWebServerRequest(AsyncWebServer*, AsyncClient*);
+    ~AsyncWebServerRequest();
+
+    AsyncClient* client() { return _client; }
+    uint8_t version() const { return _version; }
+    WebRequestMethodComposite method() const { return _method; }
+    const String& url() const { return _url; }
+    const String& host() const { return _host; }
+    const String& contentType() const { return _contentType; }
+    size_t contentLength() const { return _contentLength; }
+    bool multipart() const { return _isMultipart; }
+
+#ifndef ESP8266
+    const char* methodToString() const;
+    const char* requestedConnTypeToString() const;
+#else
+    const __FlashStringHelper* methodToString() const;
+    const __FlashStringHelper* requestedConnTypeToString() const;
+#endif
+
+    RequestedConnectionType requestedConnType() const { return _reqconntype; }
+    bool isExpectedRequestedConnType(RequestedConnectionType erct1, RequestedConnectionType erct2 = RCT_NOT_USED, RequestedConnectionType erct3 = RCT_NOT_USED);
+    void onDisconnect(ArDisconnectHandler fn);
+
+    // hash is the string representation of:
+    //  base64(user:pass) for basic or
+    //  user:realm:md5(user:realm:pass) for digest
+    bool authenticate(const char* hash);
+    bool authenticate(const char* username, const char* password, const char* realm = NULL, bool passwordIsHash = false);
+    void requestAuthentication(const char* realm = NULL, bool isDigest = true);
+
+    void setHandler(AsyncWebHandler* handler) { _handler = handler; }
+
+    /**
+     * @brief add header to collect from a response
+     *
+     * @param name
+     */
+    void addInterestingHeader(const char* name);
+    void addInterestingHeader(const String& name) { return addInterestingHeader(name.c_str()); };
+
+    /**
+     * @brief issue 302 redirect response
+     *
+     * @param url
+     */
+    void redirect(const char* url);
+    void redirect(const String& url) { return redirect(url.c_str()); };
+
+    void send(AsyncWebServerResponse* response);
+
+    void send(int code, const char* contentType = asyncsrv::empty, const char* content = asyncsrv::empty, AwsTemplateProcessor callback = nullptr) { send(beginResponse(code, contentType, content, callback)); }
+    void send(int code, const String& contentType, const String& content = emptyString, AwsTemplateProcessor callback = nullptr) { send(beginResponse(code, contentType, content, callback)); }
+
+    void send(int code, const char* contentType, const uint8_t* content, size_t len, AwsTemplateProcessor callback = nullptr) { send(beginResponse(code, contentType, content, len, callback)); }
+    void send(int code, const String& contentType, const uint8_t* content, size_t len, AwsTemplateProcessor callback = nullptr) { send(beginResponse(code, contentType, content, len, callback)); }
+
+    void send(FS& fs, const String& path, const char* contentType = asyncsrv::empty, bool download = false, AwsTemplateProcessor callback = nullptr) {
+      if (fs.exists(path) || (!download && fs.exists(path + asyncsrv::T__gz))) {
+        send(beginResponse(fs, path, contentType, download, callback));
+      } else
+        send(404);
+    }
+    void send(FS& fs, const String& path, const String& contentType = emptyString, bool download = false, AwsTemplateProcessor callback = nullptr) { send(fs, path, contentType.c_str(), download, callback); }
+
+    void send(File content, const String& path, const char* contentType = asyncsrv::empty, bool download = false, AwsTemplateProcessor callback = nullptr) {
+      if (content) {
+        send(beginResponse(content, path, contentType, download, callback));
+      } else
+        send(404);
+    }
+    void send(File content, const String& path, const String& contentType = emptyString, bool download = false, AwsTemplateProcessor callback = nullptr) { send(content, path, contentType.c_str(), download, callback); }
+
+    void send(Stream& stream, const char* contentType, size_t len, AwsTemplateProcessor callback = nullptr) { send(beginResponse(stream, contentType, len, callback)); }
+    void send(Stream& stream, const String& contentType, size_t len, AwsTemplateProcessor callback = nullptr) { send(beginResponse(stream, contentType, len, callback)); }
+
+    void send(const char* contentType, size_t len, AwsResponseFiller callback, AwsTemplateProcessor templateCallback = nullptr) { send(beginResponse(contentType, len, callback, templateCallback)); }
+    void send(const String& contentType, size_t len, AwsResponseFiller callback, AwsTemplateProcessor templateCallback = nullptr) { send(beginResponse(contentType, len, callback, templateCallback)); }
+
+    void sendChunked(const char* contentType, AwsResponseFiller callback, AwsTemplateProcessor templateCallback = nullptr) { send(beginChunkedResponse(contentType, callback, templateCallback)); }
+    void sendChunked(const String& contentType, AwsResponseFiller callback, AwsTemplateProcessor templateCallback = nullptr) { send(beginChunkedResponse(contentType, callback, templateCallback)); }
+
+    [[deprecated("Replaced by send(...)")]]
+    void send_P(int code, const String& contentType, const uint8_t* content, size_t len, AwsTemplateProcessor callback = nullptr) {
+      send(code, contentType, content, len, callback);
+    }
+    [[deprecated("Replaced by send(...)")]]
+    void send_P(int code, const String& contentType, PGM_P content, AwsTemplateProcessor callback = nullptr) {
+      send(code, contentType, content, callback);
+    }
+
+#ifdef ESP8266
+    void send(int code, const String& contentType, PGM_P content, AwsTemplateProcessor callback = nullptr) { send(beginResponse(code, contentType, content, callback)); }
+#endif
+
+    AsyncWebServerResponse* beginResponse(int code, const char* contentType = asyncsrv::empty, const char* content = asyncsrv::empty, AwsTemplateProcessor callback = nullptr);
+    AsyncWebServerResponse* beginResponse(int code, const String& contentType, const String& content = emptyString, AwsTemplateProcessor callback = nullptr) { return beginResponse(code, contentType.c_str(), content.c_str(), callback); }
+
+    AsyncWebServerResponse* beginResponse(int code, const char* contentType, const uint8_t* content, size_t len, AwsTemplateProcessor callback = nullptr);
+    AsyncWebServerResponse* beginResponse(int code, const String& contentType, const uint8_t* content, size_t len, AwsTemplateProcessor callback = nullptr) { return beginResponse(code, contentType.c_str(), content, len, callback); }
+
+    AsyncWebServerResponse* beginResponse(FS& fs, const String& path, const char* contentType = asyncsrv::empty, bool download = false, AwsTemplateProcessor callback = nullptr);
+    AsyncWebServerResponse* beginResponse(FS& fs, const String& path, const String& contentType = emptyString, bool download = false, AwsTemplateProcessor callback = nullptr) { return beginResponse(fs, path, contentType.c_str(), download, callback); }
+
+    AsyncWebServerResponse* beginResponse(File content, const String& path, const char* contentType = asyncsrv::empty, bool download = false, AwsTemplateProcessor callback = nullptr);
+    AsyncWebServerResponse* beginResponse(File content, const String& path, const String& contentType = emptyString, bool download = false, AwsTemplateProcessor callback = nullptr) { return beginResponse(content, path, contentType.c_str(), download, callback); }
+
+    AsyncWebServerResponse* beginResponse(Stream& stream, const char* contentType, size_t len, AwsTemplateProcessor callback = nullptr);
+    AsyncWebServerResponse* beginResponse(Stream& stream, const String& contentType, size_t len, AwsTemplateProcessor callback = nullptr) { return beginResponse(stream, contentType.c_str(), len, callback); }
+
+    AsyncWebServerResponse* beginResponse(const char* contentType, size_t len, AwsResponseFiller callback, AwsTemplateProcessor templateCallback = nullptr);
+    AsyncWebServerResponse* beginResponse(const String& contentType, size_t len, AwsResponseFiller callback, AwsTemplateProcessor templateCallback = nullptr) { return beginResponse(contentType.c_str(), len, callback, templateCallback); }
+
+    AsyncWebServerResponse* beginChunkedResponse(const char* contentType, AwsResponseFiller callback, AwsTemplateProcessor templateCallback = nullptr);
+    AsyncWebServerResponse* beginChunkedResponse(const String& contentType, AwsResponseFiller callback, AwsTemplateProcessor templateCallback = nullptr);
+
+    AsyncResponseStream* beginResponseStream(const char* contentType, size_t bufferSize = 1460);
+    AsyncResponseStream* beginResponseStream(const String& contentType, size_t bufferSize = 1460) { return beginResponseStream(contentType.c_str(), bufferSize); }
+
+    [[deprecated("Replaced by beginResponse(...)")]]
+    AsyncWebServerResponse* beginResponse_P(int code, const String& contentType, const uint8_t* content, size_t len, AwsTemplateProcessor callback = nullptr) {
+      return beginResponse(code, contentType, content, len, callback);
+    }
+    [[deprecated("Replaced by beginResponse(...)")]]
+    AsyncWebServerResponse* beginResponse_P(int code, const String& contentType, PGM_P content, AwsTemplateProcessor callback = nullptr) {
+      return beginResponse(code, contentType, content, callback);
+    }
+
+#ifdef ESP8266
+    AsyncWebServerResponse* beginResponse(int code, const String& contentType, PGM_P content, AwsTemplateProcessor callback = nullptr);
+#endif
+
+    size_t headers() const; // get header count
+
+    // check if header exists
+    bool hasHeader(const char* name) const;
+    bool hasHeader(const String& name) const { return hasHeader(name.c_str()); };
+#ifdef ESP8266
+    bool hasHeader(const __FlashStringHelper* data) const; // check if header exists
+#endif
+
+    const AsyncWebHeader* getHeader(const char* name) const;
+    const AsyncWebHeader* getHeader(const String& name) const { return getHeader(name.c_str()); };
+#ifdef ESP8266
+    const AsyncWebHeader* getHeader(const __FlashStringHelper* data) const;
+#endif
+    const AsyncWebHeader* getHeader(size_t num) const;
+
+    size_t params() const; // get arguments count
+    bool hasParam(const char* name, bool post = false, bool file = false) const;
+    bool hasParam(const String& name, bool post = false, bool file = false) const { return hasParam(name.c_str(), post, file); };
+#ifdef ESP8266
+    bool hasParam(const __FlashStringHelper* data, bool post = false, bool file = false) const { return hasParam(String(data).c_str(), post, file); };
+#endif
+
+    /**
+     * @brief Get the Request parameter by name
+     *
+     * @param name
+     * @param post
+     * @param file
+     * @return const AsyncWebParameter*
+     */
+    const AsyncWebParameter* getParam(const char* name, bool post = false, bool file = false) const;
+
+    const AsyncWebParameter* getParam(const String& name, bool post = false, bool file = false) const { return getParam(name.c_str(), post, file); };
+#ifdef ESP8266
+    const AsyncWebParameter* getParam(const __FlashStringHelper* data, bool post, bool file) const;
+#endif
+
+    /**
+     * @brief Get request parameter by number
+     * i.e., n-th parameter
+     * @param num
+     * @return const AsyncWebParameter*
+     */
+    const AsyncWebParameter* getParam(size_t num) const;
+
+    size_t args() const { return params(); } // get arguments count
+
+    // get request argument value by name
+    const String& arg(const char* name) const;
+    // get request argument value by name
+    const String& arg(const String& name) const { return arg(name.c_str()); };
+#ifdef ESP8266
+    const String& arg(const __FlashStringHelper* data) const; // get request argument value by F(name)
+#endif
+    const String& arg(size_t i) const;     // get request argument value by number
+    const String& argName(size_t i) const; // get request argument name by number
+    bool hasArg(const char* name) const;   // check if argument exists
+    bool hasArg(const String& name) const { return hasArg(name.c_str()); };
+#ifdef ESP8266
+    bool hasArg(const __FlashStringHelper* data) const; // check if F(argument) exists
+#endif
+
+    const String& ASYNCWEBSERVER_REGEX_ATTRIBUTE pathArg(size_t i) const;
+
+    // get request header value by name
+    const String& header(const char* name) const;
+    const String& header(const String& name) const { return header(name.c_str()); };
+
+#ifdef ESP8266
+    const String& header(const __FlashStringHelper* data) const; // get request header value by F(name)
+#endif
+
+    const String& header(size_t i) const;     // get request header value by number
+    const String& headerName(size_t i) const; // get request header name by number
+
+    String urlDecode(const String& text) const;
+};
+
+/*
+ * FILTER :: Callback to filter AsyncWebRewrite and AsyncWebHandler (done by the Server)
+ * */
+
+using ArRequestFilterFunction = std::function<bool(AsyncWebServerRequest* request)>;
+
+bool ON_STA_FILTER(AsyncWebServerRequest* request);
+
+bool ON_AP_FILTER(AsyncWebServerRequest* request);
+
+/*
+ * REWRITE :: One instance can be handle any Request (done by the Server)
+ * */
+
+class AsyncWebRewrite {
+  protected:
+    String _from;
+    String _toUrl;
+    String _params;
+    ArRequestFilterFunction _filter{nullptr};
+
+  public:
+    AsyncWebRewrite(const char* from, const char* to) : _from(from), _toUrl(to) {
+      int index = _toUrl.indexOf('?');
+      if (index > 0) {
+        _params = _toUrl.substring(index + 1);
+        _toUrl = _toUrl.substring(0, index);
+      }
+    }
+    virtual ~AsyncWebRewrite() {}
+    AsyncWebRewrite& setFilter(ArRequestFilterFunction fn) {
+      _filter = fn;
+      return *this;
+    }
+    bool filter(AsyncWebServerRequest* request) const { return _filter == NULL || _filter(request); }
+    const String& from(void) const { return _from; }
+    const String& toUrl(void) const { return _toUrl; }
+    const String& params(void) const { return _params; }
+    virtual bool match(AsyncWebServerRequest* request) { return from() == request->url() && filter(request); }
+};
+
+/*
+ * HANDLER :: One instance can be attached to any Request (done by the Server)
+ * */
+
+class AsyncWebHandler {
+  protected:
+    ArRequestFilterFunction _filter{nullptr};
+    String _username;
+    String _password;
+
+  public:
+    AsyncWebHandler() {}
+    AsyncWebHandler& setFilter(ArRequestFilterFunction fn) {
+      _filter = fn;
+      return *this;
+    }
+    AsyncWebHandler& setAuthentication(const char* username, const char* password) {
+      _username = username;
+      _password = password;
+      return *this;
+    };
+    AsyncWebHandler& setAuthentication(const String& username, const String& password) {
+      _username = username;
+      _password = password;
+      return *this;
+    };
+    bool filter(AsyncWebServerRequest* request) { return _filter == NULL || _filter(request); }
+    virtual ~AsyncWebHandler() {}
+    virtual bool canHandle(AsyncWebServerRequest* request __attribute__((unused))) {
+      return false;
+    }
+    virtual void handleRequest(AsyncWebServerRequest* request __attribute__((unused))) {}
+    virtual void handleUpload(AsyncWebServerRequest* request __attribute__((unused)), const String& filename __attribute__((unused)), size_t index __attribute__((unused)), uint8_t* data __attribute__((unused)), size_t len __attribute__((unused)), bool final __attribute__((unused))) {}
+    virtual void handleBody(AsyncWebServerRequest* request __attribute__((unused)), uint8_t* data __attribute__((unused)), size_t len __attribute__((unused)), size_t index __attribute__((unused)), size_t total __attribute__((unused))) {}
+    virtual bool isRequestHandlerTrivial() { return true; }
+};
+
+/*
+ * RESPONSE :: One instance is created for each Request (attached by the Handler)
+ * */
+
+typedef enum {
+  RESPONSE_SETUP,
+  RESPONSE_HEADERS,
+  RESPONSE_CONTENT,
+  RESPONSE_WAIT_ACK,
+  RESPONSE_END,
+  RESPONSE_FAILED
+} WebResponseState;
+
+class AsyncWebServerResponse {
+  protected:
+    int _code;
+    std::list<AsyncWebHeader> _headers;
+    String _contentType;
+    size_t _contentLength;
+    bool _sendContentLength;
+    bool _chunked;
+    size_t _headLength;
+    size_t _sentLength;
+    size_t _ackedLength;
+    size_t _writtenLength;
+    WebResponseState _state;
+
+  public:
+#ifndef ESP8266
+    static const char* responseCodeToString(int code);
+#else
+    static const __FlashStringHelper* responseCodeToString(int code);
+#endif
+
+  public:
+    AsyncWebServerResponse();
+    virtual ~AsyncWebServerResponse();
+    virtual void setCode(int code);
+    virtual void setContentLength(size_t len);
+    void setContentType(const String& type) { setContentType(type.c_str()); }
+    virtual void setContentType(const char* type);
+    virtual void addHeader(const char* name, const char* value);
+    void addHeader(const String& name, const String& value) { addHeader(name.c_str(), value.c_str()); }
+    virtual String _assembleHead(uint8_t version);
+    virtual bool _started() const;
+    virtual bool _finished() const;
+    virtual bool _failed() const;
+    virtual bool _sourceValid() const;
+    virtual void _respond(AsyncWebServerRequest* request);
+    virtual size_t _ack(AsyncWebServerRequest* request, size_t len, uint32_t time);
+};
+
+/*
+ * SERVER :: One instance
+ * */
+
+typedef std::function<void(AsyncWebServerRequest* request)> ArRequestHandlerFunction;
+typedef std::function<void(AsyncWebServerRequest* request, const String& filename, size_t index, uint8_t* data, size_t len, bool final)> ArUploadHandlerFunction;
+typedef std::function<void(AsyncWebServerRequest* request, uint8_t* data, size_t len, size_t index, size_t total)> ArBodyHandlerFunction;
+
+class AsyncWebServer {
+  protected:
+    AsyncServer _server;
+    std::list<std::shared_ptr<AsyncWebRewrite>> _rewrites;
+    std::list<std::unique_ptr<AsyncWebHandler>> _handlers;
+    AsyncCallbackWebHandler* _catchAllHandler;
+
+  public:
+    AsyncWebServer(uint16_t port);
+    ~AsyncWebServer();
+
+    void begin();
+    void end();
+
+#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
+
+    AsyncWebRewrite& addRewrite(AsyncWebRewrite* rewrite);
+
+    /**
+     * @brief (compat) Add url rewrite rule by pointer
+     * a deep copy of the pounter object will be created,
+     * it is up to user to manage further lifetime of the object in argument
+     *
+     * @param rewrite pointer to rewrite object to copy setting from
+     * @return AsyncWebRewrite& reference to a newly created rewrite rule
+     */
+    AsyncWebRewrite& addRewrite(std::shared_ptr<AsyncWebRewrite> rewrite);
+
+    /**
+     * @brief add url rewrite rule
+     *
+     * @param from
+     * @param to
+     * @return AsyncWebRewrite&
+     */
+    AsyncWebRewrite& rewrite(const char* from, const char* to);
+
+    /**
+     * @brief (compat) remove rewrite rule via referenced object
+     * this will NOT deallocate pointed object itself, internal rule with same from/to urls will be removed if any
+     * it's a compat method, better use `removeRewrite(const char* from, const char* to)`
+     * @param rewrite
+     * @return true
+     * @return false
+     */
+    bool removeRewrite(AsyncWebRewrite* rewrite);
+
+    /**
+     * @brief remove rewrite rule
+     *
+     * @param from
+     * @param to
+     * @return true
+     * @return false
+     */
+    bool removeRewrite(const char* from, const char* to);
+
+    AsyncWebHandler& addHandler(AsyncWebHandler* handler);
+    bool removeHandler(AsyncWebHandler* handler);
+
+    AsyncCallbackWebHandler& on(const char* uri, ArRequestHandlerFunction onRequest);
+    AsyncCallbackWebHandler& on(const char* uri, WebRequestMethodComposite method, ArRequestHandlerFunction onRequest);
+    AsyncCallbackWebHandler& on(const char* uri, WebRequestMethodComposite method, ArRequestHandlerFunction onRequest, ArUploadHandlerFunction onUpload);
+    AsyncCallbackWebHandler& on(const char* uri, WebRequestMethodComposite method, ArRequestHandlerFunction onRequest, ArUploadHandlerFunction onUpload, ArBodyHandlerFunction onBody);
+
+    AsyncStaticWebHandler& serveStatic(const char* uri, fs::FS& fs, const char* path, const char* cache_control = NULL);
+
+    void onNotFound(ArRequestHandlerFunction fn);  // called when handler is not assigned
+    void onFileUpload(ArUploadHandlerFunction fn); // handle file uploads
+    void onRequestBody(ArBodyHandlerFunction fn);  // handle posts with plain body content (JSON often transmitted this way as a request)
+
+    void reset(); // remove all writers and handlers, with onNotFound/onFileUpload/onRequestBody
+
+    void _handleDisconnect(AsyncWebServerRequest* request);
+    void _attachHandler(AsyncWebServerRequest* request);
+    void _rewriteRequest(AsyncWebServerRequest* request);
+};
+
+class DefaultHeaders {
+    using headers_t = std::list<AsyncWebHeader>;
+    headers_t _headers;
+
+  public:
+    DefaultHeaders() = default;
+
+    using ConstIterator = headers_t::const_iterator;
+
+    void addHeader(const String& name, const String& value) {
+      _headers.emplace_back(name, value);
+    }
+
+    ConstIterator begin() const { return _headers.begin(); }
+    ConstIterator end() const { return _headers.end(); }
+
+    DefaultHeaders(DefaultHeaders const&) = delete;
+    DefaultHeaders& operator=(DefaultHeaders const&) = delete;
+
+    static DefaultHeaders& Instance() {
+      static DefaultHeaders instance;
+      return instance;
+    }
+};
+
+#include "AsyncEventSource.h"
+#include "AsyncWebSocket.h"
+#include "WebHandlerImpl.h"
+#include "WebResponseImpl.h"
+
+#endif /* _AsyncWebServer_H_ */

lib/ESPAsyncWebServer/src/WebAuthentication.cpp

@@ -0,0 +1,249 @@
+/*
+  Asynchronous WebServer 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 "WebAuthentication.h"
+#include <libb64/cencode.h>
+#if defined(ESP32) || defined(TARGET_RP2040)
+  #include <MD5Builder.h>
+#else
+  #include "md5.h"
+#endif
+#include "literals.h"
+
+using namespace asyncsrv;
+
+// Basic Auth hash = base64("username:password")
+
+bool checkBasicAuthentication(const char* hash, const char* username, const char* password) {
+  if (username == NULL || password == NULL || hash == NULL)
+    return false;
+
+  size_t toencodeLen = strlen(username) + strlen(password) + 1;
+  size_t encodedLen = base64_encode_expected_len(toencodeLen);
+  if (strlen(hash) != encodedLen)
+// Fix from https://github.com/me-no-dev/ESPAsyncWebServer/issues/667
+#ifdef ARDUINO_ARCH_ESP32
+    if (strlen(hash) != encodedLen)
+#else
+    if (strlen(hash) != encodedLen - 1)
+#endif
+      return false;
+
+  char* toencode = new char[toencodeLen + 1];
+  if (toencode == NULL) {
+    return false;
+  }
+  char* encoded = new char[base64_encode_expected_len(toencodeLen) + 1];
+  if (encoded == NULL) {
+    delete[] toencode;
+    return false;
+  }
+  sprintf_P(toencode, PSTR("%s:%s"), username, password);
+  if (base64_encode_chars(toencode, toencodeLen, encoded) > 0 && memcmp(hash, encoded, encodedLen) == 0) {
+    delete[] toencode;
+    delete[] encoded;
+    return true;
+  }
+  delete[] toencode;
+  delete[] encoded;
+  return false;
+}
+
+static bool getMD5(uint8_t* data, uint16_t len, char* output) { // 33 bytes or more
+#if defined(ESP32) || defined(TARGET_RP2040)
+  MD5Builder md5;
+  md5.begin();
+  md5.add(data, len);
+  md5.calculate();
+  md5.getChars(output);
+#else
+  md5_context_t _ctx;
+
+  uint8_t* _buf = (uint8_t*)malloc(16);
+  if (_buf == NULL)
+    return false;
+  memset(_buf, 0x00, 16);
+
+  MD5Init(&_ctx);
+  MD5Update(&_ctx, data, len);
+  MD5Final(_buf, &_ctx);
+
+  for (uint8_t i = 0; i < 16; i++) {
+    sprintf_P(output + (i * 2), PSTR("%02x"), _buf[i]);
+  }
+
+  free(_buf);
+#endif
+  return true;
+}
+
+static String genRandomMD5() {
+#ifdef ESP8266
+  uint32_t r = RANDOM_REG32;
+#else
+  uint32_t r = rand();
+#endif
+  char* out = (char*)malloc(33);
+  if (out == NULL || !getMD5((uint8_t*)(&r), 4, out))
+    return emptyString;
+  String res = String(out);
+  free(out);
+  return res;
+}
+
+static String stringMD5(const String& in) {
+  char* out = (char*)malloc(33);
+  if (out == NULL || !getMD5((uint8_t*)(in.c_str()), in.length(), out))
+    return emptyString;
+  String res = String(out);
+  free(out);
+  return res;
+}
+
+String generateDigestHash(const char* username, const char* password, const char* realm) {
+  if (username == NULL || password == NULL || realm == NULL) {
+    return emptyString;
+  }
+  char* out = (char*)malloc(33);
+  String res = String(username);
+  res += ':';
+  res.concat(realm);
+  res += ':';
+  String in = res;
+  in.concat(password);
+  if (out == NULL || !getMD5((uint8_t*)(in.c_str()), in.length(), out))
+    return emptyString;
+  res.concat(out);
+  free(out);
+  return res;
+}
+
+String requestDigestAuthentication(const char* realm) {
+  String header(T_realm__);
+  if (realm == NULL)
+    header.concat(T_asyncesp);
+  else
+    header.concat(realm);
+  header.concat(T_auth_nonce);
+  header.concat(genRandomMD5());
+  header.concat(T__opaque);
+  header.concat(genRandomMD5());
+  header += (char)0x22; // '"'
+  return header;
+}
+
+#ifndef ESP8266
+bool checkDigestAuthentication(const char* header, const char* method, const char* username, const char* password, const char* realm, bool passwordIsHash, const char* nonce, const char* opaque, const char* uri)
+#else
+bool checkDigestAuthentication(const char* header, const __FlashStringHelper* method, const char* username, const char* password, const char* realm, bool passwordIsHash, const char* nonce, const char* opaque, const char* uri)
+#endif
+{
+  if (username == NULL || password == NULL || header == NULL || method == NULL) {
+    // os_printf("AUTH FAIL: missing requred fields\n");
+    return false;
+  }
+
+  String myHeader(header);
+  int nextBreak = myHeader.indexOf(',');
+  if (nextBreak < 0) {
+    // os_printf("AUTH FAIL: no variables\n");
+    return false;
+  }
+
+  String myUsername;
+  String myRealm;
+  String myNonce;
+  String myUri;
+  String myResponse;
+  String myQop;
+  String myNc;
+  String myCnonce;
+
+  myHeader += (char)0x2c; // ','
+  myHeader += (char)0x20; // ' '
+  do {
+    String avLine(myHeader.substring(0, nextBreak));
+    avLine.trim();
+    myHeader = myHeader.substring(nextBreak + 1);
+    nextBreak = myHeader.indexOf(',');
+
+    int eqSign = avLine.indexOf('=');
+    if (eqSign < 0) {
+      // os_printf("AUTH FAIL: no = sign\n");
+      return false;
+    }
+    String varName(avLine.substring(0, eqSign));
+    avLine = avLine.substring(eqSign + 1);
+    if (avLine.startsWith(String('"'))) {
+      avLine = avLine.substring(1, avLine.length() - 1);
+    }
+
+    if (varName.equals(T_username)) {
+      if (!avLine.equals(username)) {
+        // os_printf("AUTH FAIL: username\n");
+        return false;
+      }
+      myUsername = avLine;
+    } else if (varName.equals(T_realm)) {
+      if (realm != NULL && !avLine.equals(realm)) {
+        // os_printf("AUTH FAIL: realm\n");
+        return false;
+      }
+      myRealm = avLine;
+    } else if (varName.equals(T_nonce)) {
+      if (nonce != NULL && !avLine.equals(nonce)) {
+        // os_printf("AUTH FAIL: nonce\n");
+        return false;
+      }
+      myNonce = avLine;
+    } else if (varName.equals(T_opaque)) {
+      if (opaque != NULL && !avLine.equals(opaque)) {
+        // os_printf("AUTH FAIL: opaque\n");
+        return false;
+      }
+    } else if (varName.equals(T_uri)) {
+      if (uri != NULL && !avLine.equals(uri)) {
+        // os_printf("AUTH FAIL: uri\n");
+        return false;
+      }
+      myUri = avLine;
+    } else if (varName.equals(T_response)) {
+      myResponse = avLine;
+    } else if (varName.equals(T_qop)) {
+      myQop = avLine;
+    } else if (varName.equals(T_nc)) {
+      myNc = avLine;
+    } else if (varName.equals(T_cnonce)) {
+      myCnonce = avLine;
+    }
+  } while (nextBreak > 0);
+
+  String ha1 = (passwordIsHash) ? String(password) : stringMD5(myUsername + ':' + myRealm + ':' + password);
+  String ha2 = String(method) + ':' + myUri;
+  String response = ha1 + ':' + myNonce + ':' + myNc + ':' + myCnonce + ':' + myQop + ':' + stringMD5(ha2);
+
+  if (myResponse.equals(stringMD5(response))) {
+    // os_printf("AUTH SUCCESS\n");
+    return true;
+  }
+
+  // os_printf("AUTH FAIL: password\n");
+  return false;
+}

lib/ESPAsyncWebServer/src/WebAuthentication.h

@@ -0,0 +1,39 @@
+/*
+  Asynchronous WebServer 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 WEB_AUTHENTICATION_H_
+#define WEB_AUTHENTICATION_H_
+
+#include "Arduino.h"
+
+bool checkBasicAuthentication(const char* header, const char* username, const char* password);
+String requestDigestAuthentication(const char* realm);
+
+bool checkDigestAuthentication(const char* header, const char* method, const char* username, const char* password, const char* realm, bool passwordIsHash, const char* nonce, const char* opaque, const char* uri);
+
+#ifdef ESP8266
+bool checkDigestAuthentication(const char* header, const __FlashStringHelper* method, const char* username, const char* password, const char* realm, bool passwordIsHash, const char* nonce, const char* opaque, const char* uri);
+#endif
+
+// for storing hashed versions on the device that can be authenticated against
+String generateDigestHash(const char* username, const char* password, const char* realm);
+
+#endif

lib/ESPAsyncWebServer/src/WebHandlerImpl.h

@@ -0,0 +1,155 @@
+/*
+  Asynchronous WebServer 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 ASYNCWEBSERVERHANDLERIMPL_H_
+#define ASYNCWEBSERVERHANDLERIMPL_H_
+
+#include <string>
+#ifdef ASYNCWEBSERVER_REGEX
+  #include <regex>
+#endif
+
+#include "stddef.h"
+#include <time.h>
+
+class AsyncStaticWebHandler : public AsyncWebHandler {
+    using File = fs::File;
+    using FS = fs::FS;
+
+  private:
+    bool _getFile(AsyncWebServerRequest* request);
+    bool _fileExists(AsyncWebServerRequest* request, const String& path);
+    uint8_t _countBits(const uint8_t value) const;
+
+  protected:
+    FS _fs;
+    String _uri;
+    String _path;
+    String _default_file;
+    String _cache_control;
+    String _last_modified;
+    AwsTemplateProcessor _callback;
+    bool _isDir;
+    bool _gzipFirst;
+    uint8_t _gzipStats;
+
+  public:
+    AsyncStaticWebHandler(const char* uri, FS& fs, const char* path, const char* cache_control);
+    virtual bool canHandle(AsyncWebServerRequest* request) override final;
+    virtual void handleRequest(AsyncWebServerRequest* request) override final;
+    AsyncStaticWebHandler& setIsDir(bool isDir);
+    AsyncStaticWebHandler& setDefaultFile(const char* filename);
+    AsyncStaticWebHandler& setCacheControl(const char* cache_control);
+    AsyncStaticWebHandler& setLastModified(const char* last_modified);
+    AsyncStaticWebHandler& setLastModified(struct tm* last_modified);
+#ifdef ESP8266
+    AsyncStaticWebHandler& setLastModified(time_t last_modified);
+    AsyncStaticWebHandler& setLastModified(); // sets to current time. Make sure sntp is runing and time is updated
+#endif
+    AsyncStaticWebHandler& setTemplateProcessor(AwsTemplateProcessor newCallback) {
+      _callback = newCallback;
+      return *this;
+    }
+};
+
+class AsyncCallbackWebHandler : public AsyncWebHandler {
+  private:
+  protected:
+    String _uri;
+    WebRequestMethodComposite _method;
+    ArRequestHandlerFunction _onRequest;
+    ArUploadHandlerFunction _onUpload;
+    ArBodyHandlerFunction _onBody;
+    bool _isRegex;
+
+  public:
+    AsyncCallbackWebHandler() : _uri(), _method(HTTP_ANY), _onRequest(NULL), _onUpload(NULL), _onBody(NULL), _isRegex(false) {}
+    void setUri(const String& uri) {
+      _uri = uri;
+      _isRegex = uri.startsWith("^") && uri.endsWith("$");
+    }
+    void setMethod(WebRequestMethodComposite method) { _method = method; }
+    void onRequest(ArRequestHandlerFunction fn) { _onRequest = fn; }
+    void onUpload(ArUploadHandlerFunction fn) { _onUpload = fn; }
+    void onBody(ArBodyHandlerFunction fn) { _onBody = fn; }
+
+    virtual bool canHandle(AsyncWebServerRequest* request) override final {
+
+      if (!_onRequest)
+        return false;
+
+      if (!(_method & request->method()))
+        return false;
+
+#ifdef ASYNCWEBSERVER_REGEX
+      if (_isRegex) {
+        std::regex pattern(_uri.c_str());
+        std::smatch matches;
+        std::string s(request->url().c_str());
+        if (std::regex_search(s, matches, pattern)) {
+          for (size_t i = 1; i < matches.size(); ++i) { // start from 1
+            request->_addPathParam(matches[i].str().c_str());
+          }
+        } else {
+          return false;
+        }
+      } else
+#endif
+        if (_uri.length() && _uri.startsWith("/*.")) {
+        String uriTemplate = String(_uri);
+        uriTemplate = uriTemplate.substring(uriTemplate.lastIndexOf("."));
+        if (!request->url().endsWith(uriTemplate))
+          return false;
+      } else if (_uri.length() && _uri.endsWith("*")) {
+        String uriTemplate = String(_uri);
+        uriTemplate = uriTemplate.substring(0, uriTemplate.length() - 1);
+        if (!request->url().startsWith(uriTemplate))
+          return false;
+      } else if (_uri.length() && (_uri != request->url() && !request->url().startsWith(_uri + "/")))
+        return false;
+
+      request->addInterestingHeader("ANY");
+      return true;
+    }
+
+    virtual void handleRequest(AsyncWebServerRequest* request) override final {
+      if ((_username != "" && _password != "") && !request->authenticate(_username.c_str(), _password.c_str()))
+        return request->requestAuthentication();
+      if (_onRequest)
+        _onRequest(request);
+      else
+        request->send(500);
+    }
+    virtual void handleUpload(AsyncWebServerRequest* request, const String& filename, size_t index, uint8_t* data, size_t len, bool final) override final {
+      if ((_username != "" && _password != "") && !request->authenticate(_username.c_str(), _password.c_str()))
+        return request->requestAuthentication();
+      if (_onUpload)
+        _onUpload(request, filename, index, data, len, final);
+    }
+    virtual void handleBody(AsyncWebServerRequest* request, uint8_t* data, size_t len, size_t index, size_t total) override final {
+      if ((_username != "" && _password != "") && !request->authenticate(_username.c_str(), _password.c_str()))
+        return request->requestAuthentication();
+      if (_onBody)
+        _onBody(request, data, len, index, total);
+    }
+    virtual bool isRequestHandlerTrivial() override final { return _onRequest ? false : true; }
+};
+
+#endif /* ASYNCWEBSERVERHANDLERIMPL_H_ */

lib/ESPAsyncWebServer/src/WebHandlers.cpp

@@ -0,0 +1,250 @@
+/*
+  Asynchronous WebServer 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 "ESPAsyncWebServer.h"
+#include "WebHandlerImpl.h"
+
+using namespace asyncsrv;
+
+
+AsyncStaticWebHandler::AsyncStaticWebHandler(const char* uri, FS& fs, const char* path, const char* cache_control)
+    : _fs(fs), _uri(uri), _path(path), _default_file(F("index.htm")), _cache_control(cache_control), _last_modified(), _callback(nullptr) {
+  // Ensure leading '/'
+  if (_uri.length() == 0 || _uri[0] != '/')
+    _uri = String('/') + _uri;
+  if (_path.length() == 0 || _path[0] != '/')
+    _path = String('/') + _path;
+
+  // If path ends with '/' we assume a hint that this is a directory to improve performance.
+  // However - if it does not end with '/' we, can't assume a file, path can still be a directory.
+  _isDir = _path[_path.length() - 1] == '/';
+
+  // Remove the trailing '/' so we can handle default file
+  // Notice that root will be "" not "/"
+  if (_uri[_uri.length() - 1] == '/')
+    _uri = _uri.substring(0, _uri.length() - 1);
+  if (_path[_path.length() - 1] == '/')
+    _path = _path.substring(0, _path.length() - 1);
+
+  // Reset stats
+  _gzipFirst = false;
+  _gzipStats = 0xF8;
+}
+
+AsyncStaticWebHandler& AsyncStaticWebHandler::setIsDir(bool isDir) {
+  _isDir = isDir;
+  return *this;
+}
+
+AsyncStaticWebHandler& AsyncStaticWebHandler::setDefaultFile(const char* filename) {
+  _default_file = String(filename);
+  return *this;
+}
+
+AsyncStaticWebHandler& AsyncStaticWebHandler::setCacheControl(const char* cache_control) {
+  _cache_control = String(cache_control);
+  return *this;
+}
+
+AsyncStaticWebHandler& AsyncStaticWebHandler::setLastModified(const char* last_modified) {
+  _last_modified = last_modified;
+  return *this;
+}
+
+AsyncStaticWebHandler& AsyncStaticWebHandler::setLastModified(struct tm* last_modified) {
+  auto formatP = PSTR("%a, %d %b %Y %H:%M:%S %Z");
+  char format[strlen_P(formatP) + 1];
+  strcpy_P(format, formatP);
+
+  char result[30];
+  strftime(result, sizeof(result), format, last_modified);
+  return setLastModified((const char*)result);
+}
+
+#ifdef ESP8266
+AsyncStaticWebHandler& AsyncStaticWebHandler::setLastModified(time_t last_modified) {
+  return setLastModified((struct tm*)gmtime(&last_modified));
+}
+
+AsyncStaticWebHandler& AsyncStaticWebHandler::setLastModified() {
+  time_t last_modified;
+  if (time(&last_modified) == 0) // time is not yet set
+    return *this;
+  return setLastModified(last_modified);
+}
+#endif
+bool AsyncStaticWebHandler::canHandle(AsyncWebServerRequest* request) {
+  if (request->method() != HTTP_GET || !request->url().startsWith(_uri) || !request->isExpectedRequestedConnType(RCT_DEFAULT, RCT_HTTP)) {
+    return false;
+  }
+  if (_getFile(request)) {
+    // We interested in "If-Modified-Since" header to check if file was modified
+    if (_last_modified.length())
+      request->addInterestingHeader(F("If-Modified-Since"));
+
+    if (_cache_control.length())
+      request->addInterestingHeader(F("If-None-Match"));
+
+    return true;
+  }
+
+  return false;
+}
+
+bool AsyncStaticWebHandler::_getFile(AsyncWebServerRequest* request) {
+  // Remove the found uri
+  String path = request->url().substring(_uri.length());
+
+  // We can skip the file check and look for default if request is to the root of a directory or that request path ends with '/'
+  bool canSkipFileCheck = (_isDir && path.length() == 0) || (path.length() && path[path.length() - 1] == '/');
+
+  path = _path + path;
+
+  // Do we have a file or .gz file
+  if (!canSkipFileCheck && _fileExists(request, path))
+    return true;
+
+  // Can't handle if not default file
+  if (_default_file.length() == 0)
+    return false;
+
+  // Try to add default file, ensure there is a trailing '/' ot the path.
+  if (path.length() == 0 || path[path.length() - 1] != '/')
+    path += String('/');
+  path += _default_file;
+
+  return _fileExists(request, path);
+}
+
+#ifdef ESP32
+  #define FILE_IS_REAL(f) (f == true && !f.isDirectory())
+#else
+  #define FILE_IS_REAL(f) (f == true)
+#endif
+
+bool AsyncStaticWebHandler::_fileExists(AsyncWebServerRequest* request, const String& path) {
+  bool fileFound = false;
+  bool gzipFound = false;
+
+  String gzip = path + F(".gz");
+
+  if (_gzipFirst) {
+    if (_fs.exists(gzip)) {
+      request->_tempFile = _fs.open(gzip, fs::FileOpenMode::read);
+      gzipFound = FILE_IS_REAL(request->_tempFile);
+    }
+    if (!gzipFound) {
+      if (_fs.exists(path)) {
+        request->_tempFile = _fs.open(path, fs::FileOpenMode::read);
+        fileFound = FILE_IS_REAL(request->_tempFile);
+      }
+    }
+  } else {
+    if (_fs.exists(path)) {
+      request->_tempFile = _fs.open(path, fs::FileOpenMode::read);
+      fileFound = FILE_IS_REAL(request->_tempFile);
+    }
+    if (!fileFound) {
+      if (_fs.exists(gzip)) {
+        request->_tempFile = _fs.open(gzip, fs::FileOpenMode::read);
+        gzipFound = FILE_IS_REAL(request->_tempFile);
+      }
+    }
+  }
+
+  bool found = fileFound || gzipFound;
+
+  if (found) {
+    // Extract the file name from the path and keep it in _tempObject
+    size_t pathLen = path.length();
+    char* _tempPath = (char*)malloc(pathLen + 1);
+    snprintf_P(_tempPath, pathLen + 1, PSTR("%s"), path.c_str());
+    request->_tempObject = (void*)_tempPath;
+
+    // Calculate gzip statistic
+    _gzipStats = (_gzipStats << 1) + (gzipFound ? 1 : 0);
+    if (_gzipStats == 0x00)
+      _gzipFirst = false; // All files are not gzip
+    else if (_gzipStats == 0xFF)
+      _gzipFirst = true; // All files are gzip
+    else
+      _gzipFirst = _countBits(_gzipStats) > 4; // IF we have more gzip files - try gzip first
+  }
+
+  return found;
+}
+
+uint8_t AsyncStaticWebHandler::_countBits(const uint8_t value) const {
+  uint8_t w = value;
+  uint8_t n;
+  for (n = 0; w != 0; n++)
+    w &= w - 1;
+  return n;
+}
+
+void AsyncStaticWebHandler::handleRequest(AsyncWebServerRequest* request) {
+  // Get the filename from request->_tempObject and free it
+  String filename = String((char*)request->_tempObject);
+  free(request->_tempObject);
+  request->_tempObject = NULL;
+  if ((_username.length() && _password.length()) && !request->authenticate(_username.c_str(), _password.c_str()))
+    return request->requestAuthentication();
+
+  if (request->_tempFile == true) {
+    time_t lw = request->_tempFile.getLastWrite(); // get last file mod time (if supported by FS)
+    // set etag to lastmod timestamp if available, otherwise to size
+    String etag;
+    if (lw) {
+      setLastModified(gmtime(&lw));
+#if defined(TARGET_RP2040)
+      // time_t == long long int
+      const size_t len = 1 + 8 * sizeof(time_t);
+      char buf[len];
+      char* ret = lltoa(lw, buf, len, 10);
+      etag = ret ? String(ret) : String(request->_tempFile.size());
+#else
+      etag = String(lw);
+#endif
+    } else {
+      etag = String(request->_tempFile.size());
+    }
+    if (_last_modified.length() && _last_modified == request->header(T_IMS)) {
+      request->_tempFile.close();
+      request->send(304); // Not modified
+    } else if (_cache_control.length() && request->hasHeader(T_INM) && request->header(T_INM).equals(etag)) {
+      request->_tempFile.close();
+      AsyncWebServerResponse* response = new AsyncBasicResponse(304); // Not modified
+      response->addHeader(T_Cache_Control, _cache_control.c_str());
+      response->addHeader(T_ETag, etag.c_str());
+      request->send(response);
+    } else {
+      AsyncWebServerResponse* response = new AsyncFileResponse(request->_tempFile, filename, String(), false, _callback);
+      if (_last_modified.length())
+        response->addHeader(T_Last_Modified, _last_modified.c_str());
+      if (_cache_control.length()) {
+        response->addHeader(T_Cache_Control, _cache_control.c_str());
+        response->addHeader(T_ETag, etag.c_str());
+      }
+      request->send(response);
+    }
+  } else {
+    request->send(404);
+  }
+}

lib/ESPAsyncWebServer/src/WebRequest.cpp

@@ -0,0 +1,985 @@
+/*
+  Asynchronous WebServer 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 "ESPAsyncWebServer.h"
+#include "WebAuthentication.h"
+#include "WebResponseImpl.h"
+#include "literals.h"
+#include <cstring>
+
+#define __is_param_char(c) ((c) && ((c) != '{') && ((c) != '[') && ((c) != '&') && ((c) != '='))
+
+using namespace asyncsrv;
+
+enum { PARSE_REQ_START,
+       PARSE_REQ_HEADERS,
+       PARSE_REQ_BODY,
+       PARSE_REQ_END,
+       PARSE_REQ_FAIL };
+
+AsyncWebServerRequest::AsyncWebServerRequest(AsyncWebServer* s, AsyncClient* c)
+    : _client(c), _server(s), _handler(NULL), _response(NULL), _temp(), _parseState(0), _version(0), _method(HTTP_ANY), _url(), _host(), _contentType(), _boundary(), _authorization(), _reqconntype(RCT_HTTP), _isDigest(false), _isMultipart(false), _isPlainPost(false), _expectingContinue(false), _contentLength(0), _parsedLength(0), _multiParseState(0), _boundaryPosition(0), _itemStartIndex(0), _itemSize(0), _itemName(), _itemFilename(), _itemType(), _itemValue(), _itemBuffer(0), _itemBufferIndex(0), _itemIsFile(false), _tempObject(NULL) {
+  c->onError([](void* r, AsyncClient* c, int8_t error) { (void)c; AsyncWebServerRequest *req = (AsyncWebServerRequest*)r; req->_onError(error); }, this);
+  c->onAck([](void* r, AsyncClient* c, size_t len, uint32_t time) { (void)c; AsyncWebServerRequest *req = (AsyncWebServerRequest*)r; req->_onAck(len, time); }, this);
+  c->onDisconnect([](void* r, AsyncClient* c) { AsyncWebServerRequest *req = (AsyncWebServerRequest*)r; req->_onDisconnect(); delete c; }, this);
+  c->onTimeout([](void* r, AsyncClient* c, uint32_t time) { (void)c; AsyncWebServerRequest *req = (AsyncWebServerRequest*)r; req->_onTimeout(time); }, this);
+  c->onData([](void* r, AsyncClient* c, void* buf, size_t len) { (void)c; AsyncWebServerRequest *req = (AsyncWebServerRequest*)r; req->_onData(buf, len); }, this);
+  c->onPoll([](void* r, AsyncClient* c) { (void)c; AsyncWebServerRequest *req = ( AsyncWebServerRequest*)r; req->_onPoll(); }, this);
+}
+
+AsyncWebServerRequest::~AsyncWebServerRequest() {
+  _headers.clear();
+
+  _pathParams.clear();
+
+  _interestingHeaders.clear();
+
+  if (_response != NULL) {
+    delete _response;
+  }
+
+  if (_tempObject != NULL) {
+    free(_tempObject);
+  }
+
+  if (_tempFile) {
+    _tempFile.close();
+  }
+
+  if (_itemBuffer) {
+    free(_itemBuffer);
+  }
+}
+
+void AsyncWebServerRequest::_onData(void* buf, size_t len) {
+  size_t i = 0;
+  while (true) {
+
+    if (_parseState < PARSE_REQ_BODY) {
+      // Find new line in buf
+      char* str = (char*)buf;
+      for (i = 0; i < len; i++) {
+        if (str[i] == '\n') {
+          break;
+        }
+      }
+      if (i == len) { // No new line, just add the buffer in _temp
+        char ch = str[len - 1];
+        str[len - 1] = 0;
+        _temp.reserve(_temp.length() + len);
+        _temp.concat(str);
+        _temp.concat(ch);
+      } else {      // Found new line - extract it and parse
+        str[i] = 0; // Terminate the string at the end of the line.
+        _temp.concat(str);
+        _temp.trim();
+        _parseLine();
+        if (++i < len) {
+          // Still have more buffer to process
+          buf = str + i;
+          len -= i;
+          continue;
+        }
+      }
+    } else if (_parseState == PARSE_REQ_BODY) {
+      // A handler should be already attached at this point in _parseLine function.
+      // If handler does nothing (_onRequest is NULL), we don't need to really parse the body.
+      const bool needParse = _handler && !_handler->isRequestHandlerTrivial();
+      if (_isMultipart) {
+        if (needParse) {
+          size_t i;
+          for (i = 0; i < len; i++) {
+            _parseMultipartPostByte(((uint8_t*)buf)[i], i == len - 1);
+            _parsedLength++;
+          }
+        } else
+          _parsedLength += len;
+      } else {
+        if (_parsedLength == 0) {
+          if (_contentType.startsWith(T_app_xform_urlencoded)) {
+            _isPlainPost = true;
+          } else if (_contentType == T_text_plain && __is_param_char(((char*)buf)[0])) {
+            size_t i = 0;
+            while (i < len && __is_param_char(((char*)buf)[i++]))
+              ;
+            if (i < len && ((char*)buf)[i - 1] == '=') {
+              _isPlainPost = true;
+            }
+          }
+        }
+        if (!_isPlainPost) {
+          // check if authenticated before calling the body
+          if (_handler)
+            _handler->handleBody(this, (uint8_t*)buf, len, _parsedLength, _contentLength);
+          _parsedLength += len;
+        } else if (needParse) {
+          size_t i;
+          for (i = 0; i < len; i++) {
+            _parsedLength++;
+            _parsePlainPostChar(((uint8_t*)buf)[i]);
+          }
+        } else {
+          _parsedLength += len;
+        }
+      }
+      if (_parsedLength == _contentLength) {
+        _parseState = PARSE_REQ_END;
+        // check if authenticated before calling handleRequest and request auth instead
+        if (_handler)
+          _handler->handleRequest(this);
+        else
+          send(501);
+      }
+    }
+    break;
+  }
+}
+
+void AsyncWebServerRequest::_removeNotInterestingHeaders() {
+  if (std::any_of(std::begin(_interestingHeaders), std::end(_interestingHeaders), [](const String& str) { return str.equalsIgnoreCase(T_ANY); }))
+    return; // nothing to do
+
+  for (auto iter = std::begin(_headers); iter != std::end(_headers);) {
+    const auto name = iter->name();
+
+    if (std::none_of(std::begin(_interestingHeaders), std::end(_interestingHeaders), [&name](const String& str) { return str.equalsIgnoreCase(name); }))
+      iter = _headers.erase(iter);
+    else
+      iter++;
+  }
+}
+
+void AsyncWebServerRequest::_onPoll() {
+  // os_printf("p\n");
+  if (_response != NULL && _client != NULL && _client->canSend()) {
+    if (!_response->_finished()) {
+      _response->_ack(this, 0, 0);
+    } else {
+      AsyncWebServerResponse* r = _response;
+      _response = NULL;
+      delete r;
+
+      _client->close();
+    }
+  }
+}
+
+void AsyncWebServerRequest::_onAck(size_t len, uint32_t time) {
+  // os_printf("a:%u:%u\n", len, time);
+  if (_response != NULL) {
+    if (!_response->_finished()) {
+      _response->_ack(this, len, time);
+    } else if (_response->_finished()) {
+      AsyncWebServerResponse* r = _response;
+      _response = NULL;
+      delete r;
+
+      _client->close();
+    }
+  }
+}
+
+void AsyncWebServerRequest::_onError(int8_t error) {
+  (void)error;
+}
+
+void AsyncWebServerRequest::_onTimeout(uint32_t time) {
+  (void)time;
+  // os_printf("TIMEOUT: %u, state: %s\n", time, _client->stateToString());
+  _client->close();
+}
+
+void AsyncWebServerRequest::onDisconnect(ArDisconnectHandler fn) {
+  _onDisconnectfn = fn;
+}
+
+void AsyncWebServerRequest::_onDisconnect() {
+  // os_printf("d\n");
+  if (_onDisconnectfn) {
+    _onDisconnectfn();
+  }
+  _server->_handleDisconnect(this);
+}
+
+void AsyncWebServerRequest::_addPathParam(const char* p) {
+  _pathParams.emplace_back(p);
+}
+
+void AsyncWebServerRequest::_addGetParams(const String& params) {
+  size_t start = 0;
+  while (start < params.length()) {
+    int end = params.indexOf('&', start);
+    if (end < 0)
+      end = params.length();
+    int equal = params.indexOf('=', start);
+    if (equal < 0 || equal > end)
+      equal = end;
+    String name(params.substring(start, equal));
+    String value(equal + 1 < end ? params.substring(equal + 1, end) : String());
+    _params.emplace_back(urlDecode(name), urlDecode(value));
+    start = end + 1;
+  }
+}
+
+bool AsyncWebServerRequest::_parseReqHead() {
+  // Split the head into method, url and version
+  int index = _temp.indexOf(' ');
+  String m = _temp.substring(0, index);
+  index = _temp.indexOf(' ', index + 1);
+  String u = _temp.substring(m.length() + 1, index);
+  _temp = _temp.substring(index + 1);
+
+  if (m == T_GET) {
+    _method = HTTP_GET;
+  } else if (m == T_POST) {
+    _method = HTTP_POST;
+  } else if (m == T_DELETE) {
+    _method = HTTP_DELETE;
+  } else if (m == T_PUT) {
+    _method = HTTP_PUT;
+  } else if (m == T_PATCH) {
+    _method = HTTP_PATCH;
+  } else if (m == T_HEAD) {
+    _method = HTTP_HEAD;
+  } else if (m == T_OPTIONS) {
+    _method = HTTP_OPTIONS;
+  }
+
+  String g;
+  index = u.indexOf('?');
+  if (index > 0) {
+    g = u.substring(index + 1);
+    u = u.substring(0, index);
+  }
+  _url = urlDecode(u);
+  _addGetParams(g);
+
+  if (!_temp.startsWith(T_HTTP_1_0))
+    _version = 1;
+
+  _temp = emptyString;
+  return true;
+}
+
+bool AsyncWebServerRequest::_parseReqHeader() {
+  int index = _temp.indexOf(':');
+  if (index) {
+    String name(_temp.substring(0, index));
+    String value(_temp.substring(index + 2));
+    if (name.equalsIgnoreCase(T_Host)) {
+      _host = value;
+    } else if (name.equalsIgnoreCase(T_Content_Type)) {
+      _contentType = value.substring(0, value.indexOf(';'));
+      if (value.startsWith(T_MULTIPART_)) {
+        _boundary = value.substring(value.indexOf('=') + 1);
+        _boundary.replace(String('"'), String());
+        _isMultipart = true;
+      }
+    } else if (name.equalsIgnoreCase(T_Content_Length)) {
+      _contentLength = atoi(value.c_str());
+    } else if (name.equalsIgnoreCase(T_EXPECT) && value == T_100_CONTINUE) {
+      _expectingContinue = true;
+    } else if (name.equalsIgnoreCase(T_AUTH)) {
+      if (value.length() > 5 && value.substring(0, 5).equalsIgnoreCase(T_BASIC)) {
+        _authorization = value.substring(6);
+      } else if (value.length() > 6 && value.substring(0, 6).equalsIgnoreCase(T_DIGEST)) {
+        _isDigest = true;
+        _authorization = value.substring(7);
+      }
+    } else {
+      if (name.equalsIgnoreCase(T_UPGRADE) && value.equalsIgnoreCase(T_WS)) {
+        // WebSocket request can be uniquely identified by header: [Upgrade: websocket]
+        _reqconntype = RCT_WS;
+      } else if (name.equalsIgnoreCase(T_ACCEPT)) {
+        String lowcase(value);
+        lowcase.toLowerCase();
+#ifndef ESP8266
+        const char* substr = std::strstr(lowcase.c_str(), T_text_event_stream);
+#else
+        const char* substr = std::strstr(lowcase.c_str(), String(T_text_event_stream).c_str());
+#endif
+        if (substr != NULL) {
+          // WebEvent request can be uniquely identified by header:  [Accept: text/event-stream]
+          _reqconntype = RCT_EVENT;
+        }
+      }
+    }
+    _headers.emplace_back(name, value);
+  }
+#ifndef TARGET_RP2040
+  _temp.clear();
+#else
+  // Ancient PRI core does not have String::clear() method 8-()
+  _temp = emptyString;
+#endif
+  return true;
+}
+
+void AsyncWebServerRequest::_parsePlainPostChar(uint8_t data) {
+  if (data && (char)data != '&')
+    _temp += (char)data;
+  if (!data || (char)data == '&' || _parsedLength == _contentLength) {
+    String name(T_BODY);
+    String value(_temp);
+    if (!(_temp.charAt(0) == '{') && !(_temp.charAt(0) == '[') && _temp.indexOf('=') > 0) {
+      name = _temp.substring(0, _temp.indexOf('='));
+      value = _temp.substring(_temp.indexOf('=') + 1);
+    }
+    _params.emplace_back(urlDecode(name), urlDecode(value), true);
+
+#ifndef TARGET_RP2040
+    _temp.clear();
+#else
+    // Ancient PRI core does not have String::clear() method 8-()
+    _temp = emptyString;
+#endif
+  }
+}
+
+void AsyncWebServerRequest::_handleUploadByte(uint8_t data, bool last) {
+  _itemBuffer[_itemBufferIndex++] = data;
+
+  if (last || _itemBufferIndex == 1460) {
+    // check if authenticated before calling the upload
+    if (_handler)
+      _handler->handleUpload(this, _itemFilename, _itemSize - _itemBufferIndex, _itemBuffer, _itemBufferIndex, false);
+    _itemBufferIndex = 0;
+  }
+}
+
+enum {
+  EXPECT_BOUNDARY,
+  PARSE_HEADERS,
+  WAIT_FOR_RETURN1,
+  EXPECT_FEED1,
+  EXPECT_DASH1,
+  EXPECT_DASH2,
+  BOUNDARY_OR_DATA,
+  DASH3_OR_RETURN2,
+  EXPECT_FEED2,
+  PARSING_FINISHED,
+  PARSE_ERROR
+};
+
+void AsyncWebServerRequest::_parseMultipartPostByte(uint8_t data, bool last) {
+#define itemWriteByte(b)          \
+  do {                            \
+    _itemSize++;                  \
+    if (_itemIsFile)              \
+      _handleUploadByte(b, last); \
+    else                          \
+      _itemValue += (char)(b);    \
+  } while (0)
+
+  if (!_parsedLength) {
+    _multiParseState = EXPECT_BOUNDARY;
+    _temp = emptyString;
+    _itemName = emptyString;
+    _itemFilename = emptyString;
+    _itemType = emptyString;
+  }
+
+  if (_multiParseState == WAIT_FOR_RETURN1) {
+    if (data != '\r') {
+      itemWriteByte(data);
+    } else {
+      _multiParseState = EXPECT_FEED1;
+    }
+  } else if (_multiParseState == EXPECT_BOUNDARY) {
+    if (_parsedLength < 2 && data != '-') {
+      _multiParseState = PARSE_ERROR;
+      return;
+    } else if (_parsedLength - 2 < _boundary.length() && _boundary.c_str()[_parsedLength - 2] != data) {
+      _multiParseState = PARSE_ERROR;
+      return;
+    } else if (_parsedLength - 2 == _boundary.length() && data != '\r') {
+      _multiParseState = PARSE_ERROR;
+      return;
+    } else if (_parsedLength - 3 == _boundary.length()) {
+      if (data != '\n') {
+        _multiParseState = PARSE_ERROR;
+        return;
+      }
+      _multiParseState = PARSE_HEADERS;
+      _itemIsFile = false;
+    }
+  } else if (_multiParseState == PARSE_HEADERS) {
+    if ((char)data != '\r' && (char)data != '\n')
+      _temp += (char)data;
+    if ((char)data == '\n') {
+      if (_temp.length()) {
+        if (_temp.length() > 12 && _temp.substring(0, 12).equalsIgnoreCase(T_Content_Type)) {
+          _itemType = _temp.substring(14);
+          _itemIsFile = true;
+        } else if (_temp.length() > 19 && _temp.substring(0, 19).equalsIgnoreCase(T_Content_Disposition)) {
+          _temp = _temp.substring(_temp.indexOf(';') + 2);
+          while (_temp.indexOf(';') > 0) {
+            String name = _temp.substring(0, _temp.indexOf('='));
+            String nameVal = _temp.substring(_temp.indexOf('=') + 2, _temp.indexOf(';') - 1);
+            if (name == T_name) {
+              _itemName = nameVal;
+            } else if (name == T_filename) {
+              _itemFilename = nameVal;
+              _itemIsFile = true;
+            }
+            _temp = _temp.substring(_temp.indexOf(';') + 2);
+          }
+          String name = _temp.substring(0, _temp.indexOf('='));
+          String nameVal = _temp.substring(_temp.indexOf('=') + 2, _temp.length() - 1);
+          if (name == T_name) {
+            _itemName = nameVal;
+          } else if (name == T_filename) {
+            _itemFilename = nameVal;
+            _itemIsFile = true;
+          }
+        }
+        _temp = emptyString;
+      } else {
+        _multiParseState = WAIT_FOR_RETURN1;
+        // value starts from here
+        _itemSize = 0;
+        _itemStartIndex = _parsedLength;
+        _itemValue = emptyString;
+        if (_itemIsFile) {
+          if (_itemBuffer)
+            free(_itemBuffer);
+          _itemBuffer = (uint8_t*)malloc(1460);
+          if (_itemBuffer == NULL) {
+            _multiParseState = PARSE_ERROR;
+            return;
+          }
+          _itemBufferIndex = 0;
+        }
+      }
+    }
+  } else if (_multiParseState == EXPECT_FEED1) {
+    if (data != '\n') {
+      _multiParseState = WAIT_FOR_RETURN1;
+      itemWriteByte('\r');
+      _parseMultipartPostByte(data, last);
+    } else {
+      _multiParseState = EXPECT_DASH1;
+    }
+  } else if (_multiParseState == EXPECT_DASH1) {
+    if (data != '-') {
+      _multiParseState = WAIT_FOR_RETURN1;
+      itemWriteByte('\r');
+      itemWriteByte('\n');
+      _parseMultipartPostByte(data, last);
+    } else {
+      _multiParseState = EXPECT_DASH2;
+    }
+  } else if (_multiParseState == EXPECT_DASH2) {
+    if (data != '-') {
+      _multiParseState = WAIT_FOR_RETURN1;
+      itemWriteByte('\r');
+      itemWriteByte('\n');
+      itemWriteByte('-');
+      _parseMultipartPostByte(data, last);
+    } else {
+      _multiParseState = BOUNDARY_OR_DATA;
+      _boundaryPosition = 0;
+    }
+  } else if (_multiParseState == BOUNDARY_OR_DATA) {
+    if (_boundaryPosition < _boundary.length() && _boundary.c_str()[_boundaryPosition] != data) {
+      _multiParseState = WAIT_FOR_RETURN1;
+      itemWriteByte('\r');
+      itemWriteByte('\n');
+      itemWriteByte('-');
+      itemWriteByte('-');
+      uint8_t i;
+      for (i = 0; i < _boundaryPosition; i++)
+        itemWriteByte(_boundary.c_str()[i]);
+      _parseMultipartPostByte(data, last);
+    } else if (_boundaryPosition == _boundary.length() - 1) {
+      _multiParseState = DASH3_OR_RETURN2;
+      if (!_itemIsFile) {
+        _params.emplace_back(_itemName, _itemValue, true);
+      } else {
+        if (_itemSize) {
+          // check if authenticated before calling the upload
+          if (_handler)
+            _handler->handleUpload(this, _itemFilename, _itemSize - _itemBufferIndex, _itemBuffer, _itemBufferIndex, true);
+          _itemBufferIndex = 0;
+          _params.emplace_back(_itemName, _itemFilename, true, true, _itemSize);
+        }
+        free(_itemBuffer);
+        _itemBuffer = NULL;
+      }
+
+    } else {
+      _boundaryPosition++;
+    }
+  } else if (_multiParseState == DASH3_OR_RETURN2) {
+    if (data == '-' && (_contentLength - _parsedLength - 4) != 0) {
+      // os_printf("ERROR: The parser got to the end of the POST but is expecting %u bytes more!\nDrop an issue so we can have more info on the matter!\n", _contentLength - _parsedLength - 4);
+      _contentLength = _parsedLength + 4; // lets close the request gracefully
+    }
+    if (data == '\r') {
+      _multiParseState = EXPECT_FEED2;
+    } else if (data == '-' && _contentLength == (_parsedLength + 4)) {
+      _multiParseState = PARSING_FINISHED;
+    } else {
+      _multiParseState = WAIT_FOR_RETURN1;
+      itemWriteByte('\r');
+      itemWriteByte('\n');
+      itemWriteByte('-');
+      itemWriteByte('-');
+      uint8_t i;
+      for (i = 0; i < _boundary.length(); i++)
+        itemWriteByte(_boundary.c_str()[i]);
+      _parseMultipartPostByte(data, last);
+    }
+  } else if (_multiParseState == EXPECT_FEED2) {
+    if (data == '\n') {
+      _multiParseState = PARSE_HEADERS;
+      _itemIsFile = false;
+    } else {
+      _multiParseState = WAIT_FOR_RETURN1;
+      itemWriteByte('\r');
+      itemWriteByte('\n');
+      itemWriteByte('-');
+      itemWriteByte('-');
+      uint8_t i;
+      for (i = 0; i < _boundary.length(); i++)
+        itemWriteByte(_boundary.c_str()[i]);
+      itemWriteByte('\r');
+      _parseMultipartPostByte(data, last);
+    }
+  }
+}
+
+void AsyncWebServerRequest::_parseLine() {
+  if (_parseState == PARSE_REQ_START) {
+    if (!_temp.length()) {
+      _parseState = PARSE_REQ_FAIL;
+      _client->close();
+    } else {
+      _parseReqHead();
+      _parseState = PARSE_REQ_HEADERS;
+    }
+    return;
+  }
+
+  if (_parseState == PARSE_REQ_HEADERS) {
+    if (!_temp.length()) {
+      // end of headers
+      _server->_rewriteRequest(this);
+      _server->_attachHandler(this);
+      _removeNotInterestingHeaders();
+      if (_expectingContinue) {
+        String response(T_HTTP_100_CONT);
+        _client->write(response.c_str(), response.length());
+      }
+      // check handler for authentication
+      if (_contentLength) {
+        _parseState = PARSE_REQ_BODY;
+      } else {
+        _parseState = PARSE_REQ_END;
+        if (_handler)
+          _handler->handleRequest(this);
+        else
+          send(501);
+      }
+    } else
+      _parseReqHeader();
+  }
+}
+
+size_t AsyncWebServerRequest::headers() const {
+  return _headers.size();
+}
+
+bool AsyncWebServerRequest::hasHeader(const char* name) const {
+  for (const auto& h : _headers) {
+    if (h.name().equalsIgnoreCase(name)) {
+      return true;
+    }
+  }
+  return false;
+}
+
+#ifdef ESP8266
+bool AsyncWebServerRequest::hasHeader(const __FlashStringHelper* data) const {
+  return hasHeader(String(data));
+}
+#endif
+
+const AsyncWebHeader* AsyncWebServerRequest::getHeader(const char* name) const {
+  auto iter = std::find_if(std::begin(_headers), std::end(_headers), [&name](const AsyncWebHeader& header) { return header.name().equalsIgnoreCase(name); });
+
+  return (iter == std::end(_headers)) ? nullptr : &(*iter);
+}
+
+#ifdef ESP8266
+const AsyncWebHeader* AsyncWebServerRequest::getHeader(const __FlashStringHelper* data) const {
+  PGM_P p = reinterpret_cast<PGM_P>(data);
+  size_t n = strlen_P(p);
+  char* name = (char*)malloc(n + 1);
+  if (name) {
+    strcpy_P(name, p);
+    const AsyncWebHeader* result = getHeader(String(name));
+    free(name);
+    return result;
+  } else {
+    return nullptr;
+  }
+}
+#endif
+
+const AsyncWebHeader* AsyncWebServerRequest::getHeader(size_t num) const {
+  if (num >= _headers.size())
+    return nullptr;
+  return &(*std::next(_headers.cbegin(), num));
+}
+
+size_t AsyncWebServerRequest::params() const {
+  return _params.size();
+}
+
+bool AsyncWebServerRequest::hasParam(const char* name, bool post, bool file) const {
+  for (const auto& p : _params) {
+    if (p.name().equals(name) && p.isPost() == post && p.isFile() == file) {
+      return true;
+    }
+  }
+  return false;
+}
+
+const AsyncWebParameter* AsyncWebServerRequest::getParam(const char* name, bool post, bool file) const {
+  for (const auto& p : _params) {
+    if (p.name() == name && p.isPost() == post && p.isFile() == file) {
+      return &p;
+    }
+  }
+  return nullptr;
+}
+
+#ifdef ESP8266
+const AsyncWebParameter* AsyncWebServerRequest::getParam(const __FlashStringHelper* data, bool post, bool file) const {
+  return getParam(String(data), post, file);
+}
+#endif
+
+const AsyncWebParameter* AsyncWebServerRequest::getParam(size_t num) const {
+  if (num >= _params.size())
+    return nullptr;
+  return &(*std::next(_params.cbegin(), num));
+}
+
+void AsyncWebServerRequest::addInterestingHeader(const char* name) {
+  if (std::none_of(std::begin(_interestingHeaders), std::end(_interestingHeaders), [&name](const String& str) { return str.equalsIgnoreCase(name); }))
+    _interestingHeaders.emplace_back(name);
+}
+
+AsyncWebServerResponse* AsyncWebServerRequest::beginResponse(int code, const char* contentType, const char* content, AwsTemplateProcessor callback) {
+  if (callback)
+    return new AsyncProgmemResponse(code, contentType, (const uint8_t*)content, strlen(content), callback);
+  return new AsyncBasicResponse(code, contentType, content);
+}
+
+AsyncWebServerResponse* AsyncWebServerRequest::beginResponse(int code, const char* contentType, const uint8_t* content, size_t len, AwsTemplateProcessor callback) {
+  return new AsyncProgmemResponse(code, contentType, content, len, callback);
+}
+
+AsyncWebServerResponse* AsyncWebServerRequest::beginResponse(FS& fs, const String& path, const char* contentType, bool download, AwsTemplateProcessor callback) {
+  if (fs.exists(path) || (!download && fs.exists(path + T__gz)))
+    return new AsyncFileResponse(fs, path, contentType, download, callback);
+  return NULL;
+}
+
+AsyncWebServerResponse* AsyncWebServerRequest::beginResponse(File content, const String& path, const char* contentType, bool download, AwsTemplateProcessor callback) {
+  if (content == true)
+    return new AsyncFileResponse(content, path, contentType, download, callback);
+  return NULL;
+}
+
+AsyncWebServerResponse* AsyncWebServerRequest::beginResponse(Stream& stream, const char* contentType, size_t len, AwsTemplateProcessor callback) {
+  return new AsyncStreamResponse(stream, contentType, len, callback);
+}
+
+AsyncWebServerResponse* AsyncWebServerRequest::beginResponse(const char* contentType, size_t len, AwsResponseFiller callback, AwsTemplateProcessor templateCallback) {
+  return new AsyncCallbackResponse(contentType, len, callback, templateCallback);
+}
+
+AsyncWebServerResponse* AsyncWebServerRequest::beginChunkedResponse(const char* contentType, AwsResponseFiller callback, AwsTemplateProcessor templateCallback) {
+  if (_version)
+    return new AsyncChunkedResponse(contentType, callback, templateCallback);
+  return new AsyncCallbackResponse(contentType, 0, callback, templateCallback);
+}
+
+AsyncResponseStream* AsyncWebServerRequest::beginResponseStream(const char* contentType, size_t bufferSize) {
+  return new AsyncResponseStream(contentType, bufferSize);
+}
+
+#ifdef ESP8266
+AsyncWebServerResponse* AsyncWebServerRequest::beginResponse(int code, const String& contentType, PGM_P content, AwsTemplateProcessor callback) {
+  return new AsyncProgmemResponse(code, contentType, (const uint8_t*)content, strlen_P(content), callback);
+}
+#endif
+
+void AsyncWebServerRequest::send(AsyncWebServerResponse* response) {
+  _response = response;
+  if (_response == NULL) {
+    _client->close(true);
+    _onDisconnect();
+    return;
+  }
+  if (!_response->_sourceValid()) {
+    delete response;
+    _response = NULL;
+    send(500);
+  } else {
+    _client->setRxTimeout(0);
+    _response->_respond(this);
+  }
+}
+
+void AsyncWebServerRequest::redirect(const char* url) {
+  AsyncWebServerResponse* response = beginResponse(302);
+  response->addHeader(T_LOCATION, url);
+  send(response);
+}
+
+bool AsyncWebServerRequest::authenticate(const char* username, const char* password, const char* realm, bool passwordIsHash) {
+  if (_authorization.length()) {
+    if (_isDigest)
+      return checkDigestAuthentication(_authorization.c_str(), methodToString(), username, password, realm, passwordIsHash, NULL, NULL, NULL);
+    else if (!passwordIsHash)
+      return checkBasicAuthentication(_authorization.c_str(), username, password);
+    else
+      return _authorization.equals(password);
+  }
+  return false;
+}
+
+bool AsyncWebServerRequest::authenticate(const char* hash) {
+  if (!_authorization.length() || hash == NULL)
+    return false;
+
+  if (_isDigest) {
+    String hStr = String(hash);
+    int separator = hStr.indexOf(':');
+    if (separator <= 0)
+      return false;
+    String username = hStr.substring(0, separator);
+    hStr = hStr.substring(separator + 1);
+    separator = hStr.indexOf(':');
+    if (separator <= 0)
+      return false;
+    String realm = hStr.substring(0, separator);
+    hStr = hStr.substring(separator + 1);
+    return checkDigestAuthentication(_authorization.c_str(), methodToString(), username.c_str(), hStr.c_str(), realm.c_str(), true, NULL, NULL, NULL);
+  }
+
+  return (_authorization.equals(hash));
+}
+
+void AsyncWebServerRequest::requestAuthentication(const char* realm, bool isDigest) {
+  AsyncWebServerResponse* r = beginResponse(401);
+  if (!isDigest && realm == NULL) {
+    r->addHeader(T_WWW_AUTH, T_BASIC_REALM_LOGIN_REQ);
+  } else if (!isDigest) {
+    String header(T_BASIC_REALM);
+    header.concat(realm);
+    header += '"';
+    r->addHeader(T_WWW_AUTH, header.c_str());
+  } else {
+    String header(T_DIGEST_);
+    header.concat(requestDigestAuthentication(realm));
+    r->addHeader(T_WWW_AUTH, header.c_str());
+  }
+  send(r);
+}
+
+bool AsyncWebServerRequest::hasArg(const char* name) const {
+  for (const auto& arg : _params) {
+    if (arg.name() == name) {
+      return true;
+    }
+  }
+  return false;
+}
+
+#ifdef ESP8266
+bool AsyncWebServerRequest::hasArg(const __FlashStringHelper* data) const {
+  return hasArg(String(data).c_str());
+}
+#endif
+
+const String& AsyncWebServerRequest::arg(const char* name) const {
+  for (const auto& arg : _params) {
+    if (arg.name() == name) {
+      return arg.value();
+    }
+  }
+  return emptyString;
+}
+
+#ifdef ESP8266
+const String& AsyncWebServerRequest::arg(const __FlashStringHelper* data) const {
+  return arg(String(data).c_str());
+}
+#endif
+
+const String& AsyncWebServerRequest::arg(size_t i) const {
+  return getParam(i)->value();
+}
+
+const String& AsyncWebServerRequest::argName(size_t i) const {
+  return getParam(i)->name();
+}
+
+const String& AsyncWebServerRequest::pathArg(size_t i) const {
+  return i < _pathParams.size() ? _pathParams[i] : emptyString;
+}
+
+const String& AsyncWebServerRequest::header(const char* name) const {
+  const AsyncWebHeader* h = getHeader(name);
+  return h ? h->value() : emptyString;
+}
+
+#ifdef ESP8266
+const String& AsyncWebServerRequest::header(const __FlashStringHelper* data) const {
+  return header(String(data).c_str());
+};
+#endif
+
+const String& AsyncWebServerRequest::header(size_t i) const {
+  const AsyncWebHeader* h = getHeader(i);
+  return h ? h->value() : emptyString;
+}
+
+const String& AsyncWebServerRequest::headerName(size_t i) const {
+  const AsyncWebHeader* h = getHeader(i);
+  return h ? h->name() : emptyString;
+}
+
+String AsyncWebServerRequest::urlDecode(const String& text) const {
+  char temp[] = "0x00";
+  unsigned int len = text.length();
+  unsigned int i = 0;
+  String decoded;
+  decoded.reserve(len); // Allocate the string internal buffer - never longer from source text
+  while (i < len) {
+    char decodedChar;
+    char encodedChar = text.charAt(i++);
+    if ((encodedChar == '%') && (i + 1 < len)) {
+      temp[2] = text.charAt(i++);
+      temp[3] = text.charAt(i++);
+      decodedChar = strtol(temp, NULL, 16);
+    } else if (encodedChar == '+') {
+      decodedChar = ' ';
+    } else {
+      decodedChar = encodedChar; // normal ascii char
+    }
+    decoded.concat(decodedChar);
+  }
+  return decoded;
+}
+
+#ifndef ESP8266
+const char* AsyncWebServerRequest::methodToString() const {
+  if (_method == HTTP_ANY)
+    return T_ANY;
+  if (_method & HTTP_GET)
+    return T_GET;
+  if (_method & HTTP_POST)
+    return T_POST;
+  if (_method & HTTP_DELETE)
+    return T_DELETE;
+  if (_method & HTTP_PUT)
+    return T_PUT;
+  if (_method & HTTP_PATCH)
+    return T_PATCH;
+  if (_method & HTTP_HEAD)
+    return T_HEAD;
+  if (_method & HTTP_OPTIONS)
+    return T_OPTIONS;
+  return T_UNKNOWN;
+}
+#else  // ESP8266
+const __FlashStringHelper* AsyncWebServerRequest::methodToString() const {
+  if (_method == HTTP_ANY)
+    return FPSTR(T_ANY);
+  if (_method & HTTP_GET)
+    return FPSTR(T_GET);
+  if (_method & HTTP_POST)
+    return FPSTR(T_POST);
+  if (_method & HTTP_DELETE)
+    return FPSTR(T_DELETE);
+  if (_method & HTTP_PUT)
+    return FPSTR(T_PUT);
+  if (_method & HTTP_PATCH)
+    return FPSTR(T_PATCH);
+  if (_method & HTTP_HEAD)
+    return FPSTR(T_HEAD);
+  if (_method & HTTP_OPTIONS)
+    return FPSTR(T_OPTIONS);
+  return FPSTR(T_UNKNOWN);
+}
+#endif // ESP8266
+
+#ifndef ESP8266
+const char* AsyncWebServerRequest::requestedConnTypeToString() const {
+  switch (_reqconntype) {
+    case RCT_NOT_USED:
+      return T_RCT_NOT_USED;
+    case RCT_DEFAULT:
+      return T_RCT_DEFAULT;
+    case RCT_HTTP:
+      return T_RCT_HTTP;
+    case RCT_WS:
+      return T_RCT_WS;
+    case RCT_EVENT:
+      return T_RCT_EVENT;
+    default:
+      return T_ERROR;
+  }
+}
+#else  // ESP8266
+const __FlashStringHelper* AsyncWebServerRequest::requestedConnTypeToString() const {
+  switch (_reqconntype) {
+    case RCT_NOT_USED:
+      return FPSTR(T_RCT_NOT_USED);
+    case RCT_DEFAULT:
+      return FPSTR(T_RCT_DEFAULT);
+    case RCT_HTTP:
+      return FPSTR(T_RCT_HTTP);
+    case RCT_WS:
+      return FPSTR(T_RCT_WS);
+    case RCT_EVENT:
+      return FPSTR(T_RCT_EVENT);
+    default:
+      return FPSTR(T_ERROR);
+  }
+}
+#endif // ESP8266
+
+bool AsyncWebServerRequest::isExpectedRequestedConnType(RequestedConnectionType erct1, RequestedConnectionType erct2, RequestedConnectionType erct3) {
+  bool res = false;
+  if ((erct1 != RCT_NOT_USED) && (erct1 == _reqconntype))
+    res = true;
+  if ((erct2 != RCT_NOT_USED) && (erct2 == _reqconntype))
+    res = true;
+  if ((erct3 != RCT_NOT_USED) && (erct3 == _reqconntype))
+    res = true;
+  return res;
+}

lib/ESPAsyncWebServer/src/WebResponseImpl.h

@@ -0,0 +1,157 @@
+/*
+  Asynchronous WebServer 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 ASYNCWEBSERVERRESPONSEIMPL_H_
+#define ASYNCWEBSERVERRESPONSEIMPL_H_
+
+#ifdef Arduino_h
+  // arduino is not compatible with std::vector
+  #undef min
+  #undef max
+#endif
+#include <memory>
+#include <vector>
+#include "literals.h"
+
+// It is possible to restore these defines, but one can use _min and _max instead. Or std::min, std::max.
+
+class AsyncBasicResponse : public AsyncWebServerResponse {
+  private:
+    String _content;
+
+  public:
+    explicit AsyncBasicResponse(int code, const char* contentType = asyncsrv::empty, const char* content = asyncsrv::empty);
+    AsyncBasicResponse(int code, const String& contentType, const String& content = emptyString) : AsyncBasicResponse(code, contentType.c_str(), content.c_str()) {}
+    void _respond(AsyncWebServerRequest* request);
+    size_t _ack(AsyncWebServerRequest* request, size_t len, uint32_t time);
+    bool _sourceValid() const { return true; }
+};
+
+class AsyncAbstractResponse : public AsyncWebServerResponse {
+  private:
+    String _head;
+    // Data is inserted into cache at begin().
+    // This is inefficient with vector, but if we use some other container,
+    // we won't be able to access it as contiguous array of bytes when reading from it,
+    // so by gaining performance in one place, we'll lose it in another.
+    std::vector<uint8_t> _cache;
+    size_t _readDataFromCacheOrContent(uint8_t* data, const size_t len);
+    size_t _fillBufferAndProcessTemplates(uint8_t* buf, size_t maxLen);
+
+  protected:
+    AwsTemplateProcessor _callback;
+
+  public:
+    AsyncAbstractResponse(AwsTemplateProcessor callback = nullptr);
+    void _respond(AsyncWebServerRequest* request);
+    size_t _ack(AsyncWebServerRequest* request, size_t len, uint32_t time);
+    bool _sourceValid() const { return false; }
+    virtual size_t _fillBuffer(uint8_t* buf __attribute__((unused)), size_t maxLen __attribute__((unused))) { return 0; }
+};
+
+#ifndef TEMPLATE_PLACEHOLDER
+  #define TEMPLATE_PLACEHOLDER '%'
+#endif
+
+#define TEMPLATE_PARAM_NAME_LENGTH 32
+class AsyncFileResponse : public AsyncAbstractResponse {
+    using File = fs::File;
+    using FS = fs::FS;
+
+  private:
+    File _content;
+    String _path;
+    void _setContentTypeFromPath(const String& path);
+
+  public:
+    AsyncFileResponse(FS& fs, const String& path, const char* contentType = asyncsrv::empty, bool download = false, AwsTemplateProcessor callback = nullptr);
+    AsyncFileResponse(FS& fs, const String& path, const String& contentType, bool download = false, AwsTemplateProcessor callback = nullptr) : AsyncFileResponse(fs, path, contentType.c_str(), download, callback) {}
+    AsyncFileResponse(File content, const String& path, const char* contentType = asyncsrv::empty, bool download = false, AwsTemplateProcessor callback = nullptr);
+    AsyncFileResponse(File content, const String& path, const String& contentType, bool download = false, AwsTemplateProcessor callack = nullptr) : AsyncFileResponse(content, path, contentType.c_str(), download, callack) {}
+    ~AsyncFileResponse();
+    bool _sourceValid() const { return !!(_content); }
+    virtual size_t _fillBuffer(uint8_t* buf, size_t maxLen) override;
+};
+
+class AsyncStreamResponse : public AsyncAbstractResponse {
+  private:
+    Stream* _content;
+
+  public:
+    AsyncStreamResponse(Stream& stream, const char* contentType, size_t len, AwsTemplateProcessor callback = nullptr);
+    AsyncStreamResponse(Stream& stream, const String& contentType, size_t len, AwsTemplateProcessor callback = nullptr) : AsyncStreamResponse(stream, contentType.c_str(), len, callback) {}
+    bool _sourceValid() const { return !!(_content); }
+    virtual size_t _fillBuffer(uint8_t* buf, size_t maxLen) override;
+};
+
+class AsyncCallbackResponse : public AsyncAbstractResponse {
+  private:
+    AwsResponseFiller _content;
+    size_t _filledLength;
+
+  public:
+    AsyncCallbackResponse(const char* contentType, size_t len, AwsResponseFiller callback, AwsTemplateProcessor templateCallback = nullptr);
+    AsyncCallbackResponse(const String& contentType, size_t len, AwsResponseFiller callback, AwsTemplateProcessor templateCallback = nullptr) : AsyncCallbackResponse(contentType.c_str(), len, callback, templateCallback) {}
+    bool _sourceValid() const { return !!(_content); }
+    virtual size_t _fillBuffer(uint8_t* buf, size_t maxLen) override;
+};
+
+class AsyncChunkedResponse : public AsyncAbstractResponse {
+  private:
+    AwsResponseFiller _content;
+    size_t _filledLength;
+
+  public:
+    AsyncChunkedResponse(const char* contentType, AwsResponseFiller callback, AwsTemplateProcessor templateCallback = nullptr);
+    AsyncChunkedResponse(const String& contentType, AwsResponseFiller callback, AwsTemplateProcessor templateCallback = nullptr) : AsyncChunkedResponse(contentType.c_str(), callback, templateCallback) {}
+    bool _sourceValid() const { return !!(_content); }
+    virtual size_t _fillBuffer(uint8_t* buf, size_t maxLen) override;
+};
+
+class AsyncProgmemResponse : public AsyncAbstractResponse {
+  private:
+    const uint8_t* _content;
+    size_t _readLength;
+
+  public:
+    AsyncProgmemResponse(int code, const char* contentType, const uint8_t* content, size_t len, AwsTemplateProcessor callback = nullptr);
+    AsyncProgmemResponse(int code, const String& contentType, const uint8_t* content, size_t len, AwsTemplateProcessor callback = nullptr) : AsyncProgmemResponse(code, contentType.c_str(), content, len, callback) {}
+    bool _sourceValid() const { return true; }
+    virtual size_t _fillBuffer(uint8_t* buf, size_t maxLen) override;
+};
+
+class cbuf;
+
+class AsyncResponseStream : public AsyncAbstractResponse, public Print {
+  private:
+    std::unique_ptr<cbuf> _content;
+
+  public:
+    AsyncResponseStream(const char* contentType, size_t bufferSize);
+    AsyncResponseStream(const String& contentType, size_t bufferSize) : AsyncResponseStream(contentType.c_str(), bufferSize) {}
+    ~AsyncResponseStream();
+    bool _sourceValid() const { return (_state < RESPONSE_END); }
+    virtual size_t _fillBuffer(uint8_t* buf, size_t maxLen) override;
+    size_t write(const uint8_t* data, size_t len);
+    size_t write(uint8_t data);
+    using Print::write;
+};
+
+#endif /* ASYNCWEBSERVERRESPONSEIMPL_H_ */

lib/ESPAsyncWebServer/src/WebResponses.cpp

@@ -0,0 +1,849 @@
+/*
+  Asynchronous WebServer 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 "ESPAsyncWebServer.h"
+#include "WebResponseImpl.h"
+#include "cbuf.h"
+
+using namespace asyncsrv;
+
+// Since ESP8266 does not link memchr by default, here's its implementation.
+void* memchr(void* ptr, int ch, size_t count) {
+  unsigned char* p = static_cast<unsigned char*>(ptr);
+  while (count--)
+    if (*p++ == static_cast<unsigned char>(ch))
+      return --p;
+  return nullptr;
+}
+
+/*
+ * Abstract Response
+ *
+ */
+
+#ifndef ESP8266
+const char* AsyncWebServerResponse::responseCodeToString(int code) {
+  switch (code) {
+    case 100:
+      return T_HTTP_CODE_100;
+    case 101:
+      return T_HTTP_CODE_101;
+    case 200:
+      return T_HTTP_CODE_200;
+    case 201:
+      return T_HTTP_CODE_201;
+    case 202:
+      return T_HTTP_CODE_202;
+    case 203:
+      return T_HTTP_CODE_203;
+    case 204:
+      return T_HTTP_CODE_204;
+    case 205:
+      return T_HTTP_CODE_205;
+    case 206:
+      return T_HTTP_CODE_206;
+    case 300:
+      return T_HTTP_CODE_300;
+    case 301:
+      return T_HTTP_CODE_301;
+    case 302:
+      return T_HTTP_CODE_302;
+    case 303:
+      return T_HTTP_CODE_303;
+    case 304:
+      return T_HTTP_CODE_304;
+    case 305:
+      return T_HTTP_CODE_305;
+    case 307:
+      return T_HTTP_CODE_307;
+    case 400:
+      return T_HTTP_CODE_400;
+    case 401:
+      return T_HTTP_CODE_401;
+    case 402:
+      return T_HTTP_CODE_402;
+    case 403:
+      return T_HTTP_CODE_403;
+    case 404:
+      return T_HTTP_CODE_404;
+    case 405:
+      return T_HTTP_CODE_405;
+    case 406:
+      return T_HTTP_CODE_406;
+    case 407:
+      return T_HTTP_CODE_407;
+    case 408:
+      return T_HTTP_CODE_408;
+    case 409:
+      return T_HTTP_CODE_409;
+    case 410:
+      return T_HTTP_CODE_410;
+    case 411:
+      return T_HTTP_CODE_411;
+    case 412:
+      return T_HTTP_CODE_412;
+    case 413:
+      return T_HTTP_CODE_413;
+    case 414:
+      return T_HTTP_CODE_414;
+    case 415:
+      return T_HTTP_CODE_415;
+    case 416:
+      return T_HTTP_CODE_416;
+    case 417:
+      return T_HTTP_CODE_417;
+    case 500:
+      return T_HTTP_CODE_500;
+    case 501:
+      return T_HTTP_CODE_501;
+    case 502:
+      return T_HTTP_CODE_502;
+    case 503:
+      return T_HTTP_CODE_503;
+    case 504:
+      return T_HTTP_CODE_504;
+    case 505:
+      return T_HTTP_CODE_505;
+    default:
+      return T_HTTP_CODE_ANY;
+  }
+}
+#else // ESP8266
+const __FlashStringHelper* AsyncWebServerResponse::responseCodeToString(int code)
+{
+  switch (code) {
+    case 100:
+      return FPSTR(T_HTTP_CODE_100);
+    case 101:
+      return FPSTR(T_HTTP_CODE_101);
+    case 200:
+      return FPSTR(T_HTTP_CODE_200);
+    case 201:
+      return FPSTR(T_HTTP_CODE_201);
+    case 202:
+      return FPSTR(T_HTTP_CODE_202);
+    case 203:
+      return FPSTR(T_HTTP_CODE_203);
+    case 204:
+      return FPSTR(T_HTTP_CODE_204);
+    case 205:
+      return FPSTR(T_HTTP_CODE_205);
+    case 206:
+      return FPSTR(T_HTTP_CODE_206);
+    case 300:
+      return FPSTR(T_HTTP_CODE_300);
+    case 301:
+      return FPSTR(T_HTTP_CODE_301);
+    case 302:
+      return FPSTR(T_HTTP_CODE_302);
+    case 303:
+      return FPSTR(T_HTTP_CODE_303);
+    case 304:
+      return FPSTR(T_HTTP_CODE_304);
+    case 305:
+      return FPSTR(T_HTTP_CODE_305);
+    case 307:
+      return FPSTR(T_HTTP_CODE_307);
+    case 400:
+      return FPSTR(T_HTTP_CODE_400);
+    case 401:
+      return FPSTR(T_HTTP_CODE_401);
+    case 402:
+      return FPSTR(T_HTTP_CODE_402);
+    case 403:
+      return FPSTR(T_HTTP_CODE_403);
+    case 404:
+      return FPSTR(T_HTTP_CODE_404);
+    case 405:
+      return FPSTR(T_HTTP_CODE_405);
+    case 406:
+      return FPSTR(T_HTTP_CODE_406);
+    case 407:
+      return FPSTR(T_HTTP_CODE_407);
+    case 408:
+      return FPSTR(T_HTTP_CODE_408);
+    case 409:
+      return FPSTR(T_HTTP_CODE_409);
+    case 410:
+      return FPSTR(T_HTTP_CODE_410);
+    case 411:
+      return FPSTR(T_HTTP_CODE_411);
+    case 412:
+      return FPSTR(T_HTTP_CODE_412);
+    case 413:
+      return FPSTR(T_HTTP_CODE_413);
+    case 414:
+      return FPSTR(T_HTTP_CODE_414);
+    case 415:
+      return FPSTR(T_HTTP_CODE_415);
+    case 416:
+      return FPSTR(T_HTTP_CODE_416);
+    case 417:
+      return FPSTR(T_HTTP_CODE_417);
+    case 500:
+      return FPSTR(T_HTTP_CODE_500);
+    case 501:
+      return FPSTR(T_HTTP_CODE_501);
+    case 502:
+      return FPSTR(T_HTTP_CODE_502);
+    case 503:
+      return FPSTR(T_HTTP_CODE_503);
+    case 504:
+      return FPSTR(T_HTTP_CODE_504);
+    case 505:
+      return FPSTR(T_HTTP_CODE_505);
+    default:
+      return FPSTR(T_HTTP_CODE_ANY);
+  }
+}
+#endif // ESP8266
+
+AsyncWebServerResponse::AsyncWebServerResponse()
+    : _code(0), _contentType(), _contentLength(0), _sendContentLength(true), _chunked(false), _headLength(0), _sentLength(0), _ackedLength(0), _writtenLength(0), _state(RESPONSE_SETUP) {
+  for (const auto& header : DefaultHeaders::Instance()) {
+    _headers.emplace_back(header);
+  }
+}
+
+AsyncWebServerResponse::~AsyncWebServerResponse() = default;
+
+void AsyncWebServerResponse::setCode(int code) {
+  if (_state == RESPONSE_SETUP)
+    _code = code;
+}
+
+void AsyncWebServerResponse::setContentLength(size_t len) {
+  if (_state == RESPONSE_SETUP)
+    _contentLength = len;
+}
+
+void AsyncWebServerResponse::setContentType(const char* type) {
+  if (_state == RESPONSE_SETUP)
+    _contentType = type;
+}
+
+void AsyncWebServerResponse::addHeader(const char* name, const char* value) {
+  _headers.emplace_back(name, value);
+}
+
+String AsyncWebServerResponse::_assembleHead(uint8_t version) {
+  if (version) {
+    addHeader(T_Accept_Ranges, T_none);
+    if (_chunked)
+      addHeader(Transfer_Encoding, T_chunked);
+  }
+  String out;
+  int bufSize = 300;
+  char buf[bufSize];
+
+#ifndef ESP8266
+  snprintf(buf, bufSize, "HTTP/1.%d %d %s\r\n", version, _code, responseCodeToString(_code));
+#else
+  snprintf_P(buf, bufSize, PSTR("HTTP/1.%d %d %s\r\n"), version, _code, String(responseCodeToString(_code)).c_str());
+#endif
+  out.concat(buf);
+
+  if (_sendContentLength) {
+    snprintf_P(buf, bufSize, PSTR("Content-Length: %d\r\n"), _contentLength);
+    out.concat(buf);
+  }
+  if (_contentType.length()) {
+    snprintf_P(buf, bufSize, PSTR("Content-Type: %s\r\n"), _contentType.c_str());
+    out.concat(buf);
+  }
+
+  for (const auto& header : _headers) {
+    snprintf_P(buf, bufSize, PSTR("%s: %s\r\n"), header.name().c_str(), header.value().c_str());
+    out.concat(buf);
+  }
+  _headers.clear();
+
+  out.concat(T_rn);
+  _headLength = out.length();
+  return out;
+}
+
+bool AsyncWebServerResponse::_started() const { return _state > RESPONSE_SETUP; }
+bool AsyncWebServerResponse::_finished() const { return _state > RESPONSE_WAIT_ACK; }
+bool AsyncWebServerResponse::_failed() const { return _state == RESPONSE_FAILED; }
+bool AsyncWebServerResponse::_sourceValid() const { return false; }
+void AsyncWebServerResponse::_respond(AsyncWebServerRequest* request) {
+  _state = RESPONSE_END;
+  request->client()->close();
+}
+size_t AsyncWebServerResponse::_ack(AsyncWebServerRequest* request, size_t len, uint32_t time) {
+  (void)request;
+  (void)len;
+  (void)time;
+  return 0;
+}
+
+/*
+ * String/Code Response
+ * */
+AsyncBasicResponse::AsyncBasicResponse(int code, const char* contentType, const char* content) {
+  _code = code;
+  _content = content;
+  _contentType = contentType;
+  if (_content.length()) {
+    _contentLength = _content.length();
+    if (!_contentType.length())
+      _contentType = T_text_plain;
+  }
+  addHeader(T_Connection, T_close);
+}
+
+void AsyncBasicResponse::_respond(AsyncWebServerRequest* request) {
+  _state = RESPONSE_HEADERS;
+  String out = _assembleHead(request->version());
+  size_t outLen = out.length();
+  size_t space = request->client()->space();
+  if (!_contentLength && space >= outLen) {
+    _writtenLength += request->client()->write(out.c_str(), outLen);
+    _state = RESPONSE_WAIT_ACK;
+  } else if (_contentLength && space >= outLen + _contentLength) {
+    out += _content;
+    outLen += _contentLength;
+    _writtenLength += request->client()->write(out.c_str(), outLen);
+    _state = RESPONSE_WAIT_ACK;
+  } else if (space && space < outLen) {
+    String partial = out.substring(0, space);
+    _content = out.substring(space) + _content;
+    _contentLength += outLen - space;
+    _writtenLength += request->client()->write(partial.c_str(), partial.length());
+    _state = RESPONSE_CONTENT;
+  } else if (space > outLen && space < (outLen + _contentLength)) {
+    size_t shift = space - outLen;
+    outLen += shift;
+    _sentLength += shift;
+    out += _content.substring(0, shift);
+    _content = _content.substring(shift);
+    _writtenLength += request->client()->write(out.c_str(), outLen);
+    _state = RESPONSE_CONTENT;
+  } else {
+    _content = out + _content;
+    _contentLength += outLen;
+    _state = RESPONSE_CONTENT;
+  }
+}
+
+size_t AsyncBasicResponse::_ack(AsyncWebServerRequest* request, size_t len, uint32_t time) {
+  (void)time;
+  _ackedLength += len;
+  if (_state == RESPONSE_CONTENT) {
+    size_t available = _contentLength - _sentLength;
+    size_t space = request->client()->space();
+    // we can fit in this packet
+    if (space > available) {
+      _writtenLength += request->client()->write(_content.c_str(), available);
+      _content = emptyString;
+      _state = RESPONSE_WAIT_ACK;
+      return available;
+    }
+    // send some data, the rest on ack
+    String out = _content.substring(0, space);
+    _content = _content.substring(space);
+    _sentLength += space;
+    _writtenLength += request->client()->write(out.c_str(), space);
+    return space;
+  } else if (_state == RESPONSE_WAIT_ACK) {
+    if (_ackedLength >= _writtenLength) {
+      _state = RESPONSE_END;
+    }
+  }
+  return 0;
+}
+
+/*
+ * Abstract Response
+ * */
+
+AsyncAbstractResponse::AsyncAbstractResponse(AwsTemplateProcessor callback) : _callback(callback) {
+  // In case of template processing, we're unable to determine real response size
+  if (callback) {
+    _contentLength = 0;
+    _sendContentLength = false;
+    _chunked = true;
+  }
+}
+
+void AsyncAbstractResponse::_respond(AsyncWebServerRequest* request) {
+  addHeader(T_Connection, T_close);
+  _head = _assembleHead(request->version());
+  _state = RESPONSE_HEADERS;
+  _ack(request, 0, 0);
+}
+
+size_t AsyncAbstractResponse::_ack(AsyncWebServerRequest* request, size_t len, uint32_t time) {
+  (void)time;
+  if (!_sourceValid()) {
+    _state = RESPONSE_FAILED;
+    request->client()->close();
+    return 0;
+  }
+  _ackedLength += len;
+  size_t space = request->client()->space();
+
+  size_t headLen = _head.length();
+  if (_state == RESPONSE_HEADERS) {
+    if (space >= headLen) {
+      _state = RESPONSE_CONTENT;
+      space -= headLen;
+    } else {
+      String out = _head.substring(0, space);
+      _head = _head.substring(space);
+      _writtenLength += request->client()->write(out.c_str(), out.length());
+      return out.length();
+    }
+  }
+
+  if (_state == RESPONSE_CONTENT) {
+    size_t outLen;
+    if (_chunked) {
+      if (space <= 8) {
+        return 0;
+      }
+      outLen = space;
+    } else if (!_sendContentLength) {
+      outLen = space;
+    } else {
+      outLen = ((_contentLength - _sentLength) > space) ? space : (_contentLength - _sentLength);
+    }
+
+    uint8_t* buf = (uint8_t*)malloc(outLen + headLen);
+    if (!buf) {
+      // os_printf("_ack malloc %d failed\n", outLen+headLen);
+      return 0;
+    }
+
+    if (headLen) {
+      memcpy(buf, _head.c_str(), _head.length());
+    }
+
+    size_t readLen = 0;
+
+    if (_chunked) {
+      // HTTP 1.1 allows leading zeros in chunk length. Or spaces may be added.
+      // See RFC2616 sections 2, 3.6.1.
+      readLen = _fillBufferAndProcessTemplates(buf + headLen + 6, outLen - 8);
+      if (readLen == RESPONSE_TRY_AGAIN) {
+        free(buf);
+        return 0;
+      }
+      outLen = sprintf_P((char*)buf + headLen, PSTR("%x"), readLen) + headLen;
+      while (outLen < headLen + 4)
+        buf[outLen++] = ' ';
+      buf[outLen++] = '\r';
+      buf[outLen++] = '\n';
+      outLen += readLen;
+      buf[outLen++] = '\r';
+      buf[outLen++] = '\n';
+    } else {
+      readLen = _fillBufferAndProcessTemplates(buf + headLen, outLen);
+      if (readLen == RESPONSE_TRY_AGAIN) {
+        free(buf);
+        return 0;
+      }
+      outLen = readLen + headLen;
+    }
+
+    if (headLen) {
+      _head = emptyString;
+    }
+
+    if (outLen) {
+      _writtenLength += request->client()->write((const char*)buf, outLen);
+    }
+
+    if (_chunked) {
+      _sentLength += readLen;
+    } else {
+      _sentLength += outLen - headLen;
+    }
+
+    free(buf);
+
+    if ((_chunked && readLen == 0) || (!_sendContentLength && outLen == 0) || (!_chunked && _sentLength == _contentLength)) {
+      _state = RESPONSE_WAIT_ACK;
+    }
+    return outLen;
+
+  } else if (_state == RESPONSE_WAIT_ACK) {
+    if (!_sendContentLength || _ackedLength >= _writtenLength) {
+      _state = RESPONSE_END;
+      if (!_chunked && !_sendContentLength)
+        request->client()->close(true);
+    }
+  }
+  return 0;
+}
+
+size_t AsyncAbstractResponse::_readDataFromCacheOrContent(uint8_t* data, const size_t len) {
+  // If we have something in cache, copy it to buffer
+  const size_t readFromCache = std::min(len, _cache.size());
+  if (readFromCache) {
+    memcpy(data, _cache.data(), readFromCache);
+    _cache.erase(_cache.begin(), _cache.begin() + readFromCache);
+  }
+  // If we need to read more...
+  const size_t needFromFile = len - readFromCache;
+  const size_t readFromContent = _fillBuffer(data + readFromCache, needFromFile);
+  return readFromCache + readFromContent;
+}
+
+size_t AsyncAbstractResponse::_fillBufferAndProcessTemplates(uint8_t* data, size_t len) {
+  if (!_callback)
+    return _fillBuffer(data, len);
+
+  const size_t originalLen = len;
+  len = _readDataFromCacheOrContent(data, len);
+  // Now we've read 'len' bytes, either from cache or from file
+  // Search for template placeholders
+  uint8_t* pTemplateStart = data;
+  while ((pTemplateStart < &data[len]) && (pTemplateStart = (uint8_t*)memchr(pTemplateStart, TEMPLATE_PLACEHOLDER, &data[len - 1] - pTemplateStart + 1))) { // data[0] ... data[len - 1]
+    uint8_t* pTemplateEnd = (pTemplateStart < &data[len - 1]) ? (uint8_t*)memchr(pTemplateStart + 1, TEMPLATE_PLACEHOLDER, &data[len - 1] - pTemplateStart) : nullptr;
+    // temporary buffer to hold parameter name
+    uint8_t buf[TEMPLATE_PARAM_NAME_LENGTH + 1];
+    String paramName;
+    // If closing placeholder is found:
+    if (pTemplateEnd) {
+      // prepare argument to callback
+      const size_t paramNameLength = std::min((size_t)sizeof(buf) - 1, (size_t)(pTemplateEnd - pTemplateStart - 1));
+      if (paramNameLength) {
+        memcpy(buf, pTemplateStart + 1, paramNameLength);
+        buf[paramNameLength] = 0;
+        paramName = String(reinterpret_cast<char*>(buf));
+      } else { // double percent sign encountered, this is single percent sign escaped.
+        // remove the 2nd percent sign
+        memmove(pTemplateEnd, pTemplateEnd + 1, &data[len] - pTemplateEnd - 1);
+        len += _readDataFromCacheOrContent(&data[len - 1], 1) - 1;
+        ++pTemplateStart;
+      }
+    } else if (&data[len - 1] - pTemplateStart + 1 < TEMPLATE_PARAM_NAME_LENGTH + 2) { // closing placeholder not found, check if it's in the remaining file data
+      memcpy(buf, pTemplateStart + 1, &data[len - 1] - pTemplateStart);
+      const size_t readFromCacheOrContent = _readDataFromCacheOrContent(buf + (&data[len - 1] - pTemplateStart), TEMPLATE_PARAM_NAME_LENGTH + 2 - (&data[len - 1] - pTemplateStart + 1));
+      if (readFromCacheOrContent) {
+        pTemplateEnd = (uint8_t*)memchr(buf + (&data[len - 1] - pTemplateStart), TEMPLATE_PLACEHOLDER, readFromCacheOrContent);
+        if (pTemplateEnd) {
+          // prepare argument to callback
+          *pTemplateEnd = 0;
+          paramName = String(reinterpret_cast<char*>(buf));
+          // Copy remaining read-ahead data into cache
+          _cache.insert(_cache.begin(), pTemplateEnd + 1, buf + (&data[len - 1] - pTemplateStart) + readFromCacheOrContent);
+          pTemplateEnd = &data[len - 1];
+        } else // closing placeholder not found in file data, store found percent symbol as is and advance to the next position
+        {
+          // but first, store read file data in cache
+          _cache.insert(_cache.begin(), buf + (&data[len - 1] - pTemplateStart), buf + (&data[len - 1] - pTemplateStart) + readFromCacheOrContent);
+          ++pTemplateStart;
+        }
+      } else // closing placeholder not found in content data, store found percent symbol as is and advance to the next position
+        ++pTemplateStart;
+    } else // closing placeholder not found in content data, store found percent symbol as is and advance to the next position
+      ++pTemplateStart;
+    if (paramName.length()) {
+      // call callback and replace with result.
+      // Everything in range [pTemplateStart, pTemplateEnd] can be safely replaced with parameter value.
+      // Data after pTemplateEnd may need to be moved.
+      // The first byte of data after placeholder is located at pTemplateEnd + 1.
+      // It should be located at pTemplateStart + numBytesCopied (to begin right after inserted parameter value).
+      const String paramValue(_callback(paramName));
+      const char* pvstr = paramValue.c_str();
+      const unsigned int pvlen = paramValue.length();
+      const size_t numBytesCopied = std::min(pvlen, static_cast<unsigned int>(&data[originalLen - 1] - pTemplateStart + 1));
+      // make room for param value
+      // 1. move extra data to cache if parameter value is longer than placeholder AND if there is no room to store
+      if ((pTemplateEnd + 1 < pTemplateStart + numBytesCopied) && (originalLen - (pTemplateStart + numBytesCopied - pTemplateEnd - 1) < len)) {
+        _cache.insert(_cache.begin(), &data[originalLen - (pTemplateStart + numBytesCopied - pTemplateEnd - 1)], &data[len]);
+        // 2. parameter value is longer than placeholder text, push the data after placeholder which not saved into cache further to the end
+        memmove(pTemplateStart + numBytesCopied, pTemplateEnd + 1, &data[originalLen] - pTemplateStart - numBytesCopied);
+        len = originalLen; // fix issue with truncated data, not sure if it has any side effects
+      } else if (pTemplateEnd + 1 != pTemplateStart + numBytesCopied)
+        // 2. Either parameter value is shorter than placeholder text OR there is enough free space in buffer to fit.
+        //    Move the entire data after the placeholder
+        memmove(pTemplateStart + numBytesCopied, pTemplateEnd + 1, &data[len] - pTemplateEnd - 1);
+      // 3. replace placeholder with actual value
+      memcpy(pTemplateStart, pvstr, numBytesCopied);
+      // If result is longer than buffer, copy the remainder into cache (this could happen only if placeholder text itself did not fit entirely in buffer)
+      if (numBytesCopied < pvlen) {
+        _cache.insert(_cache.begin(), pvstr + numBytesCopied, pvstr + pvlen);
+      } else if (pTemplateStart + numBytesCopied < pTemplateEnd + 1) { // result is copied fully; if result is shorter than placeholder text...
+        // there is some free room, fill it from cache
+        const size_t roomFreed = pTemplateEnd + 1 - pTemplateStart - numBytesCopied;
+        const size_t totalFreeRoom = originalLen - len + roomFreed;
+        len += _readDataFromCacheOrContent(&data[len - roomFreed], totalFreeRoom) - roomFreed;
+      } else { // result is copied fully; it is longer than placeholder text
+        const size_t roomTaken = pTemplateStart + numBytesCopied - pTemplateEnd - 1;
+        len = std::min(len + roomTaken, originalLen);
+      }
+    }
+  } // while(pTemplateStart)
+  return len;
+}
+
+/*
+ * File Response
+ * */
+
+AsyncFileResponse::~AsyncFileResponse() {
+  if (_content)
+    _content.close();
+}
+
+void AsyncFileResponse::_setContentTypeFromPath(const String& path) {
+#if HAVE_EXTERN_GET_Content_Type_FUNCTION
+  #ifndef ESP8266
+    extern const char* getContentType(const String& path);
+  #else
+    extern const __FlashStringHelper* getContentType(const String& path);
+  #endif
+  _contentType = getContentType(path);
+#else
+  if (path.endsWith(T__html))
+    _contentType = T_text_html;
+  else if (path.endsWith(T__htm))
+    _contentType = T_text_html;
+  else if (path.endsWith(T__css))
+    _contentType = T_text_css;
+  else if (path.endsWith(T__json))
+    _contentType = T_application_json;
+  else if (path.endsWith(T__js))
+    _contentType = T_application_javascript;
+  else if (path.endsWith(T__png))
+    _contentType = T_image_png;
+  else if (path.endsWith(T__gif))
+    _contentType = T_image_gif;
+  else if (path.endsWith(T__jpg))
+    _contentType = T_image_jpeg;
+  else if (path.endsWith(T__ico))
+    _contentType = T_image_x_icon;
+  else if (path.endsWith(T__svg))
+    _contentType = T_image_svg_xml;
+  else if (path.endsWith(T__eot))
+    _contentType = T_font_eot;
+  else if (path.endsWith(T__woff))
+    _contentType = T_font_woff;
+  else if (path.endsWith(T__woff2))
+    _contentType = T_font_woff2;
+  else if (path.endsWith(T__ttf))
+    _contentType = T_font_ttf;
+  else if (path.endsWith(T__xml))
+    _contentType = T_text_xml;
+  else if (path.endsWith(T__pdf))
+    _contentType = T_application_pdf;
+  else if (path.endsWith(T__zip))
+    _contentType = T_application_zip;
+  else if (path.endsWith(T__gz))
+    _contentType = T_application_x_gzip;
+  else
+    _contentType = T_text_plain;
+#endif
+}
+
+AsyncFileResponse::AsyncFileResponse(FS& fs, const String& path, const char* contentType, bool download, AwsTemplateProcessor callback) : AsyncAbstractResponse(callback) {
+  _code = 200;
+  _path = path;
+
+  if (!download && !fs.exists(_path) && fs.exists(_path + T__gz)) {
+    _path = _path + T__gz;
+    addHeader(T_Content_Encoding, T_gzip);
+    _callback = nullptr; // Unable to process zipped templates
+    _sendContentLength = true;
+    _chunked = false;
+  }
+
+  _content = fs.open(_path, fs::FileOpenMode::read);
+  _contentLength = _content.size();
+
+  if (strlen(contentType) == 0)
+    _setContentTypeFromPath(path);
+  else
+    _contentType = contentType;
+
+  int filenameStart = path.lastIndexOf('/') + 1;
+  char buf[26 + path.length() - filenameStart];
+  char* filename = (char*)path.c_str() + filenameStart;
+
+  if (download) {
+    // set filename and force download
+    snprintf_P(buf, sizeof(buf), PSTR("attachment; filename=\"%s\""), filename);
+  } else {
+    // set filename and force rendering
+    snprintf_P(buf, sizeof(buf), PSTR("inline"));
+  }
+  addHeader(T_Content_Disposition, buf);
+}
+
+AsyncFileResponse::AsyncFileResponse(File content, const String& path, const char* contentType, bool download, AwsTemplateProcessor callback) : AsyncAbstractResponse(callback) {
+  _code = 200;
+  _path = path;
+
+  if (!download && String(content.name()).endsWith(T__gz) && !path.endsWith(T__gz)) {
+    addHeader(T_Content_Encoding, T_gzip);
+    _callback = nullptr; // Unable to process gzipped templates
+    _sendContentLength = true;
+    _chunked = false;
+  }
+
+  _content = content;
+  _contentLength = _content.size();
+
+  if (strlen(contentType) == 0)
+    _setContentTypeFromPath(path);
+  else
+    _contentType = contentType;
+
+  int filenameStart = path.lastIndexOf('/') + 1;
+  char buf[26 + path.length() - filenameStart];
+  char* filename = (char*)path.c_str() + filenameStart;
+
+  if (download) {
+    snprintf_P(buf, sizeof(buf), PSTR("attachment; filename=\"%s\""), filename);
+  } else {
+    snprintf_P(buf, sizeof(buf), PSTR("inline"));
+  }
+  addHeader(T_Content_Disposition, buf);
+}
+
+size_t AsyncFileResponse::_fillBuffer(uint8_t* data, size_t len) {
+  return _content.read(data, len);
+}
+
+/*
+ * Stream Response
+ * */
+
+AsyncStreamResponse::AsyncStreamResponse(Stream& stream, const char* contentType, size_t len, AwsTemplateProcessor callback) : AsyncAbstractResponse(callback) {
+  _code = 200;
+  _content = &stream;
+  _contentLength = len;
+  _contentType = contentType;
+}
+
+size_t AsyncStreamResponse::_fillBuffer(uint8_t* data, size_t len) {
+  size_t available = _content->available();
+  size_t outLen = (available > len) ? len : available;
+  size_t i;
+  for (i = 0; i < outLen; i++)
+    data[i] = _content->read();
+  return outLen;
+}
+
+/*
+ * Callback Response
+ * */
+
+AsyncCallbackResponse::AsyncCallbackResponse(const char* contentType, size_t len, AwsResponseFiller callback, AwsTemplateProcessor templateCallback) : AsyncAbstractResponse(templateCallback) {
+  _code = 200;
+  _content = callback;
+  _contentLength = len;
+  if (!len)
+    _sendContentLength = false;
+  _contentType = contentType;
+  _filledLength = 0;
+}
+
+size_t AsyncCallbackResponse::_fillBuffer(uint8_t* data, size_t len) {
+  size_t ret = _content(data, len, _filledLength);
+  if (ret != RESPONSE_TRY_AGAIN) {
+    _filledLength += ret;
+  }
+  return ret;
+}
+
+/*
+ * Chunked Response
+ * */
+
+AsyncChunkedResponse::AsyncChunkedResponse(const char* contentType, AwsResponseFiller callback, AwsTemplateProcessor processorCallback) : AsyncAbstractResponse(processorCallback) {
+  _code = 200;
+  _content = callback;
+  _contentLength = 0;
+  _contentType = contentType;
+  _sendContentLength = false;
+  _chunked = true;
+  _filledLength = 0;
+}
+
+size_t AsyncChunkedResponse::_fillBuffer(uint8_t* data, size_t len) {
+  size_t ret = _content(data, len, _filledLength);
+  if (ret != RESPONSE_TRY_AGAIN) {
+    _filledLength += ret;
+  }
+  return ret;
+}
+
+/*
+ * Progmem Response
+ * */
+
+AsyncProgmemResponse::AsyncProgmemResponse(int code, const char* contentType, const uint8_t* content, size_t len, AwsTemplateProcessor callback) : AsyncAbstractResponse(callback) {
+  _code = code;
+  _content = content;
+  _contentType = contentType;
+  _contentLength = len;
+  _readLength = 0;
+}
+
+size_t AsyncProgmemResponse::_fillBuffer(uint8_t* data, size_t len) {
+  size_t left = _contentLength - _readLength;
+  if (left > len) {
+    memcpy_P(data, _content + _readLength, len);
+    _readLength += len;
+    return len;
+  }
+  memcpy_P(data, _content + _readLength, left);
+  _readLength += left;
+  return left;
+}
+
+/*
+ * Response Stream (You can print/write/printf to it, up to the contentLen bytes)
+ * */
+
+AsyncResponseStream::AsyncResponseStream(const char* contentType, size_t bufferSize) {
+  _code = 200;
+  _contentLength = 0;
+  _contentType = contentType;
+  _content = std::unique_ptr<cbuf>(new cbuf(bufferSize)); // std::make_unique<cbuf>(bufferSize);
+}
+
+AsyncResponseStream::~AsyncResponseStream() = default;
+
+size_t AsyncResponseStream::_fillBuffer(uint8_t* buf, size_t maxLen) {
+  return _content->read((char*)buf, maxLen);
+}
+
+size_t AsyncResponseStream::write(const uint8_t* data, size_t len) {
+  if (_started())
+    return 0;
+
+  if (len > _content->room()) {
+    size_t needed = len - _content->room();
+    _content->resizeAdd(needed);
+  }
+  size_t written = _content->write((const char*)data, len);
+  _contentLength += written;
+  return written;
+}
+
+size_t AsyncResponseStream::write(uint8_t data) {
+  return write(&data, 1);
+}

lib/ESPAsyncWebServer/src/WebServer.cpp

@@ -0,0 +1,227 @@
+/*
+  Asynchronous WebServer 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 "ESPAsyncWebServer.h"
+#include "WebHandlerImpl.h"
+
+using namespace asyncsrv;
+
+bool ON_STA_FILTER(AsyncWebServerRequest* request) {
+  #ifndef CONFIG_IDF_TARGET_ESP32H2
+  return WiFi.localIP() == request->client()->localIP();
+  #else
+  return false;
+  #endif
+}
+
+bool ON_AP_FILTER(AsyncWebServerRequest* request) {
+  #ifndef CONFIG_IDF_TARGET_ESP32H2
+  return WiFi.localIP() != request->client()->localIP();
+  #else
+  return false;
+  #endif
+}
+
+#ifndef HAVE_FS_FILE_OPEN_MODE
+const char* fs::FileOpenMode::read = "r";
+const char* fs::FileOpenMode::write = "w";
+const char* fs::FileOpenMode::append = "a";
+#endif
+
+AsyncWebServer::AsyncWebServer(uint16_t port)
+    : _server(port) {
+  _catchAllHandler = new AsyncCallbackWebHandler();
+  if (_catchAllHandler == NULL)
+    return;
+  _server.onClient([](void* s, AsyncClient* c) {
+    if (c == NULL)
+      return;
+    c->setRxTimeout(3);
+    AsyncWebServerRequest* r = new AsyncWebServerRequest((AsyncWebServer*)s, c);
+    if (r == NULL) {
+      c->close(true);
+      c->free();
+      delete c;
+    }
+  },
+                   this);
+}
+
+AsyncWebServer::~AsyncWebServer() {
+  reset();
+  end();
+  if (_catchAllHandler)
+    delete _catchAllHandler;
+}
+
+AsyncWebRewrite& AsyncWebServer::addRewrite(std::shared_ptr<AsyncWebRewrite> rewrite) {
+  _rewrites.emplace_back(rewrite);
+  return *_rewrites.back().get();
+}
+
+AsyncWebRewrite& AsyncWebServer::addRewrite(AsyncWebRewrite* rewrite) {
+  _rewrites.emplace_back(rewrite);
+  return *_rewrites.back().get();
+}
+
+bool AsyncWebServer::removeRewrite(AsyncWebRewrite* rewrite) {
+  return removeRewrite(rewrite->from().c_str(), rewrite->toUrl().c_str());
+}
+
+bool AsyncWebServer::removeRewrite(const char* from, const char* to) {
+  for (auto r = _rewrites.begin(); r != _rewrites.end(); ++r) {
+    if (r->get()->from() == from && r->get()->toUrl() == to) {
+      _rewrites.erase(r);
+      return true;
+    }
+  }
+  return false;
+}
+
+AsyncWebRewrite& AsyncWebServer::rewrite(const char* from, const char* to) {
+  _rewrites.emplace_back(std::make_shared<AsyncWebRewrite>(from, to));
+  return *_rewrites.back().get();
+}
+
+AsyncWebHandler& AsyncWebServer::addHandler(AsyncWebHandler* handler) {
+  _handlers.emplace_back(handler);
+  return *(_handlers.back().get());
+}
+
+bool AsyncWebServer::removeHandler(AsyncWebHandler* handler) {
+  for (auto i = _handlers.begin(); i != _handlers.end(); ++i) {
+    if (i->get() == handler) {
+      _handlers.erase(i);
+      return true;
+    }
+  }
+  return false;
+}
+
+void AsyncWebServer::begin() {
+  _server.setNoDelay(true);
+  _server.begin();
+}
+
+void AsyncWebServer::end() {
+  _server.end();
+}
+
+#if ASYNC_TCP_SSL_ENABLED
+void AsyncWebServer::onSslFileRequest(AcSSlFileHandler cb, void* arg) {
+  _server.onSslFileRequest(cb, arg);
+}
+
+void AsyncWebServer::beginSecure(const char* cert, const char* key, const char* password) {
+  _server.beginSecure(cert, key, password);
+}
+#endif
+
+void AsyncWebServer::_handleDisconnect(AsyncWebServerRequest* request) {
+  delete request;
+}
+
+void AsyncWebServer::_rewriteRequest(AsyncWebServerRequest* request) {
+  for (const auto& r : _rewrites) {
+    if (r->match(request)) {
+      request->_url = r->toUrl();
+      request->_addGetParams(r->params());
+    }
+  }
+}
+
+void AsyncWebServer::_attachHandler(AsyncWebServerRequest* request) {
+  for (auto& h : _handlers) {
+    if (h->filter(request) && h->canHandle(request)) {
+      request->setHandler(h.get());
+      return;
+    }
+  }
+
+  request->addInterestingHeader(T_ANY);
+  request->setHandler(_catchAllHandler);
+}
+
+AsyncCallbackWebHandler& AsyncWebServer::on(const char* uri, WebRequestMethodComposite method, ArRequestHandlerFunction onRequest, ArUploadHandlerFunction onUpload, ArBodyHandlerFunction onBody) {
+  AsyncCallbackWebHandler* handler = new AsyncCallbackWebHandler();
+  handler->setUri(uri);
+  handler->setMethod(method);
+  handler->onRequest(onRequest);
+  handler->onUpload(onUpload);
+  handler->onBody(onBody);
+  addHandler(handler);
+  return *handler;
+}
+
+AsyncCallbackWebHandler& AsyncWebServer::on(const char* uri, WebRequestMethodComposite method, ArRequestHandlerFunction onRequest, ArUploadHandlerFunction onUpload) {
+  AsyncCallbackWebHandler* handler = new AsyncCallbackWebHandler();
+  handler->setUri(uri);
+  handler->setMethod(method);
+  handler->onRequest(onRequest);
+  handler->onUpload(onUpload);
+  addHandler(handler);
+  return *handler;
+}
+
+AsyncCallbackWebHandler& AsyncWebServer::on(const char* uri, WebRequestMethodComposite method, ArRequestHandlerFunction onRequest) {
+  AsyncCallbackWebHandler* handler = new AsyncCallbackWebHandler();
+  handler->setUri(uri);
+  handler->setMethod(method);
+  handler->onRequest(onRequest);
+  addHandler(handler);
+  return *handler;
+}
+
+AsyncCallbackWebHandler& AsyncWebServer::on(const char* uri, ArRequestHandlerFunction onRequest) {
+  AsyncCallbackWebHandler* handler = new AsyncCallbackWebHandler();
+  handler->setUri(uri);
+  handler->onRequest(onRequest);
+  addHandler(handler);
+  return *handler;
+}
+
+AsyncStaticWebHandler& AsyncWebServer::serveStatic(const char* uri, fs::FS& fs, const char* path, const char* cache_control) {
+  AsyncStaticWebHandler* handler = new AsyncStaticWebHandler(uri, fs, path, cache_control);
+  addHandler(handler);
+  return *handler;
+}
+
+void AsyncWebServer::onNotFound(ArRequestHandlerFunction fn) {
+  _catchAllHandler->onRequest(fn);
+}
+
+void AsyncWebServer::onFileUpload(ArUploadHandlerFunction fn) {
+  _catchAllHandler->onUpload(fn);
+}
+
+void AsyncWebServer::onRequestBody(ArBodyHandlerFunction fn) {
+  _catchAllHandler->onBody(fn);
+}
+
+void AsyncWebServer::reset() {
+  _rewrites.clear();
+  _handlers.clear();
+
+  if (_catchAllHandler != NULL) {
+    _catchAllHandler->onRequest(NULL);
+    _catchAllHandler->onUpload(NULL);
+    _catchAllHandler->onBody(NULL);
+  }
+}

lib/ESPAsyncWebServer/src/literals.h

@@ -0,0 +1,345 @@
+#pragma once
+
+namespace asyncsrv {
+
+static constexpr const char* empty = "";
+
+#ifndef ESP8622
+static constexpr const char* T_100_CONTINUE     = "100-continue";
+static constexpr const char* T_ACCEPT           = "Accept";
+static constexpr const char* T_Accept_Ranges    = "Accept-Ranges";
+static constexpr const char* T_app_xform_urlencoded = "application/x-www-form-urlencoded";
+static constexpr const char* T_AUTH             = "Authorization";
+static constexpr const char* T_BASIC            = "Basic";
+static constexpr const char* T_BASIC_REALM      = "Basic realm=\"";
+static constexpr const char* T_BASIC_REALM_LOGIN_REQ = "Basic realm=\"Login Required\"";
+static constexpr const char* T_BODY             = "body";
+static constexpr const char* T_Cache_Control    = "Cache-Control";
+static constexpr const char* T_chunked          = "chunked";
+static constexpr const char* T_close            = "close";
+static constexpr const char* T_Connection       = "Connection";
+static constexpr const char* T_Content_Disposition     = "Content-Disposition";
+static constexpr const char* T_Content_Encoding = "Content-Encoding";
+static constexpr const char* T_Content_Length   = "Content-Length";
+static constexpr const char* T_Content_Type     = "Content-Type";
+static constexpr const char* T_Cookie           = "Cookie";
+static constexpr const char* T_DIGEST           = "Digest";
+static constexpr const char* T_DIGEST_          = "Digest ";
+static constexpr const char* T_ETag             = "ETag";
+static constexpr const char* T_EXPECT           = "Expect";
+static constexpr const char* T_HTTP_1_0         = "HTTP/1.0";
+static constexpr const char* T_HTTP_100_CONT    = "HTTP/1.1 100 Continue\r\n\r\n";
+static constexpr const char* T_IMS              = "If-Modified-Since";
+static constexpr const char* T_INM              = "If-None-Match";
+static constexpr const char* T_keep_alive       = "keep-alive";
+static constexpr const char* T_Last_Event_ID    = "Last-Event-ID";
+static constexpr const char* T_Last_Modified    = "Last-Modified";
+static constexpr const char* T_LOCATION         = "Location";
+static constexpr const char* T_MULTIPART_       = "multipart/";
+static constexpr const char* T_no_cache         = "no-cache";
+static constexpr const char* T_none             = "none";
+static constexpr const char* T_UPGRADE          = "Upgrade";
+static constexpr const char* T_WS               = "websocket";
+static constexpr const char* T_WWW_AUTH         = "WWW-Authenticate";
+static constexpr const char* Transfer_Encoding  = "Transfer-Encoding";
+
+// HTTP Methods
+static constexpr const char* T_ANY      = "ANY";
+static constexpr const char* T_GET      = "GET";
+static constexpr const char* T_POST     = "POST";
+static constexpr const char* T_PUT      = "PUT";
+static constexpr const char* T_DELETE   = "DELETE";
+static constexpr const char* T_PATCH    = "PATCH";
+static constexpr const char* T_HEAD     = "HEAD";
+static constexpr const char* T_OPTIONS  = "OPTIONS";
+static constexpr const char* T_UNKNOWN  = "UNKNOWN";
+
+// Req content types
+static constexpr const char* T_RCT_NOT_USED = "RCT_NOT_USED";
+static constexpr const char* T_RCT_DEFAULT  = "RCT_DEFAULT";
+static constexpr const char* T_RCT_HTTP     = "RCT_HTTP";
+static constexpr const char* T_RCT_WS       = "RCT_WS";
+static constexpr const char* T_RCT_EVENT    = "RCT_EVENT";
+static constexpr const char* T_ERROR        = "ERROR";
+
+// extentions & MIME-Types
+static constexpr const char* T__css  = ".css";
+static constexpr const char* T__eot  = ".eot";
+static constexpr const char* T__gif  = ".gif";
+static constexpr const char* T__gz   = ".gz";
+static constexpr const char* T__htm  = ".htm";
+static constexpr const char* T__html = ".html";
+static constexpr const char* T__ico  = ".ico";
+static constexpr const char* T__jpg  = ".jpg";
+static constexpr const char* T__js   = ".js";
+static constexpr const char* T__json = ".json";
+static constexpr const char* T__pdf  = ".pdf";
+static constexpr const char* T__png  = ".png";
+static constexpr const char* T__svg  = ".svg";
+static constexpr const char* T__ttf  = ".ttf";
+static constexpr const char* T__woff = ".woff";
+static constexpr const char* T__woff2    = ".woff2";
+static constexpr const char* T__xml  = ".xml";
+static constexpr const char* T__zip  = ".zip";
+static constexpr const char* T_application_javascript   = "application/javascript";
+static constexpr const char* T_application_json         = "application/json";
+static constexpr const char* T_application_msgpack      = "application/msgpack";
+static constexpr const char* T_application_pdf          = "application/pdf";
+static constexpr const char* T_application_x_gzip       = "application/x-gzip";
+static constexpr const char* T_application_zip          = "application/zip";
+static constexpr const char* T_font_eot                 = "font/eot";
+static constexpr const char* T_font_ttf                 = "font/ttf";
+static constexpr const char* T_font_woff                = "font/woff";
+static constexpr const char* T_font_woff2               = "font/woff2";
+static constexpr const char* T_image_gif                = "image/gif";
+static constexpr const char* T_image_jpeg               = "image/jpeg";
+static constexpr const char* T_image_png                = "image/png";
+static constexpr const char* T_image_svg_xml            = "image/svg+xml";
+static constexpr const char* T_image_x_icon             = "image/x-icon";
+static constexpr const char* T_text_css                 = "text/css";
+static constexpr const char* T_text_event_stream        = "text/event-stream";
+static constexpr const char* T_text_html                = "text/html";
+static constexpr const char* T_text_plain               = "text/plain";
+static constexpr const char* T_text_xml                 = "text/xml";
+
+// Responce codes
+static constexpr const char* T_HTTP_CODE_100 = "Continue";
+static constexpr const char* T_HTTP_CODE_101 = "Switching Protocols";
+static constexpr const char* T_HTTP_CODE_200 = "OK";
+static constexpr const char* T_HTTP_CODE_201 = "Created";
+static constexpr const char* T_HTTP_CODE_202 = "Accepted";
+static constexpr const char* T_HTTP_CODE_203 = "Non-Authoritative Information";
+static constexpr const char* T_HTTP_CODE_204 = "No Content";
+static constexpr const char* T_HTTP_CODE_205 = "Reset Content";
+static constexpr const char* T_HTTP_CODE_206 = "Partial Content";
+static constexpr const char* T_HTTP_CODE_300 = "Multiple Choices";
+static constexpr const char* T_HTTP_CODE_301 = "Moved Permanently";
+static constexpr const char* T_HTTP_CODE_302 = "Found";
+static constexpr const char* T_HTTP_CODE_303 = "See Other";
+static constexpr const char* T_HTTP_CODE_304 = "Not Modified";
+static constexpr const char* T_HTTP_CODE_305 = "Use Proxy";
+static constexpr const char* T_HTTP_CODE_307 = "Temporary Redirect";
+static constexpr const char* T_HTTP_CODE_400 = "Bad Request";
+static constexpr const char* T_HTTP_CODE_401 = "Unauthorized";
+static constexpr const char* T_HTTP_CODE_402 = "Payment Required";
+static constexpr const char* T_HTTP_CODE_403 = "Forbidden";
+static constexpr const char* T_HTTP_CODE_404 = "Not Found";
+static constexpr const char* T_HTTP_CODE_405 = "Method Not Allowed";
+static constexpr const char* T_HTTP_CODE_406 = "Not Acceptable";
+static constexpr const char* T_HTTP_CODE_407 = "Proxy Authentication Required";
+static constexpr const char* T_HTTP_CODE_408 = "Request Time-out";
+static constexpr const char* T_HTTP_CODE_409 = "Conflict";
+static constexpr const char* T_HTTP_CODE_410 = "Gone";
+static constexpr const char* T_HTTP_CODE_411 = "Length Required";
+static constexpr const char* T_HTTP_CODE_412 = "Precondition Failed";
+static constexpr const char* T_HTTP_CODE_413 = "Request Entity Too Large";
+static constexpr const char* T_HTTP_CODE_414 = "Request-URI Too Large";
+static constexpr const char* T_HTTP_CODE_415 = "Unsupported Media Type";
+static constexpr const char* T_HTTP_CODE_416 = "Requested range not satisfiable";
+static constexpr const char* T_HTTP_CODE_417 = "Expectation Failed";
+static constexpr const char* T_HTTP_CODE_500 = "Internal Server Error";
+static constexpr const char* T_HTTP_CODE_501 = "Not Implemented";
+static constexpr const char* T_HTTP_CODE_502 = "Bad Gateway";
+static constexpr const char* T_HTTP_CODE_503 = "Service Unavailable";
+static constexpr const char* T_HTTP_CODE_504 = "Gateway Time-out";
+static constexpr const char* T_HTTP_CODE_505 = "HTTP Version not supported";
+static constexpr const char* T_HTTP_CODE_ANY = "Unknown code";
+
+// other
+static constexpr const char* T__opaque  = "\", opaque=\"";
+static constexpr const char* T_13       = "13";
+static constexpr const char* T_asyncesp = "asyncesp";
+static constexpr const char* T_auth_nonce = "\", qop=\"auth\", nonce=\"";
+static constexpr const char* T_cnonce   = "cnonce";
+static constexpr const char* T_data_    = "data: ";
+static constexpr const char* T_event_   = "event: ";
+static constexpr const char* T_filename = "filename";
+static constexpr const char* T_gzip     = "gzip";
+static constexpr const char* T_Host     = "Host";
+static constexpr const char* T_id__     = "id: ";
+static constexpr const char* T_name     = "name";
+static constexpr const char* T_nc       = "nc";
+static constexpr const char* T_nonce    = "nonce";
+static constexpr const char* T_opaque   = "opaque";
+static constexpr const char* T_qop      = "qop";
+static constexpr const char* T_realm    = "realm";
+static constexpr const char* T_realm__  = "realm=\"";
+static constexpr const char* T_response = "response";
+static constexpr const char* T_retry_   = "retry: ";
+static constexpr const char* T_rn       = "\r\n";
+static constexpr const char* T_rnrn     = "\r\n\r\n";
+static constexpr const char* T_uri      = "uri";
+static constexpr const char* T_username = "username";
+
+
+#else   // ESP8622
+
+static const char T_100_CONTINUE[] PROGMEM = "100-continue";
+static const char T_ACCEPT[] PROGMEM = "Accept";
+static const char T_Accept_Ranges[] PROGMEM = "Accept-Ranges";
+static const char T_app_xform_urlencoded[] PROGMEM = "application/x-www-form-urlencoded";
+static const char T_AUTH[] PROGMEM = "Authorization";
+static const char T_BASIC[] PROGMEM = "Basic";
+static const char T_BASIC_REALM[] PROGMEM = "Basic realm=\"";
+static const char T_BASIC_REALM_LOGIN_REQ[] PROGMEM = "Basic realm=\"Login Required\"";
+static const char T_BODY[] PROGMEM = "body";
+static const char T_Cache_Control[] PROGMEM = "Cache-Control";
+static const char T_chunked[] PROGMEM = "chunked";
+static const char T_close[] PROGMEM = "close";
+static const char T_Connection[] PROGMEM = "Connection";
+static const char T_Content_Disposition[] PROGMEM = "Content-Disposition";
+static const char T_Content_Encoding[] PROGMEM = "Content-Encoding";
+static const char T_Content_Length[] PROGMEM = "Content-Length";
+static const char T_Content_Type[] PROGMEM = "Content-Type";
+static const char T_Cookie[] PROGMEM = "Cookie";
+static const char T_DIGEST[] PROGMEM = "Digest";
+static const char T_DIGEST_[] PROGMEM = "Digest ";
+static const char T_ETag[] PROGMEM = "ETag";
+static const char T_EXPECT[] PROGMEM = "Expect";
+static const char T_HTTP_1_0[] PROGMEM = "HTTP/1.0";
+static const char T_HTTP_100_CONT[] PROGMEM = "HTTP/1.1 100 Continue\r\n\r\n";
+static const char T_IMS[] PROGMEM = "If-Modified-Since";
+static const char T_INM[] PROGMEM = "If-None-Match";
+static const char T_keep_alive[] PROGMEM = "keep-alive";
+static const char T_Last_Event_ID[] PROGMEM = "Last-Event-ID";
+static const char T_Last_Modified[] PROGMEM = "Last-Modified";
+static const char T_LOCATION[] PROGMEM = "Location";
+static const char T_MULTIPART_[] PROGMEM = "multipart/";
+static const char T_no_cache[] PROGMEM = "no-cache";
+static const char T_none[] PROGMEM = "none";
+static const char T_UPGRADE[] PROGMEM = "Upgrade";
+static const char T_WS[] PROGMEM = "websocket";
+static const char T_WWW_AUTH[] PROGMEM = "WWW-Authenticate";
+static const char Transfer_Encoding[] PROGMEM = "Transfer-Encoding";
+
+// HTTP Methods
+static const char T_ANY[] PROGMEM = "ANY";
+static const char T_GET[] PROGMEM = "GET";
+static const char T_POST[] PROGMEM = "POST";
+static const char T_PUT[] PROGMEM = "PUT";
+static const char T_DELETE[] PROGMEM = "DELETE";
+static const char T_PATCH[] PROGMEM = "PATCH";
+static const char T_HEAD[] PROGMEM = "HEAD";
+static const char T_OPTIONS[] PROGMEM = "OPTIONS";
+static const char T_UNKNOWN[] PROGMEM = "UNKNOWN";
+
+// Req content types
+static const char T_RCT_NOT_USED[] PROGMEM = "RCT_NOT_USED";
+static const char T_RCT_DEFAULT[] PROGMEM = "RCT_DEFAULT";
+static const char T_RCT_HTTP[] PROGMEM = "RCT_HTTP";
+static const char T_RCT_WS[] PROGMEM = "RCT_WS";
+static const char T_RCT_EVENT[] PROGMEM = "RCT_EVENT";
+static const char T_ERROR[] PROGMEM = "ERROR";
+
+// extentions & MIME-Types
+static const char T__css[] PROGMEM = ".css";
+static const char T__eot[] PROGMEM = ".eot";
+static const char T__gif[] PROGMEM = ".gif";
+static const char T__gz[] PROGMEM = ".gz";
+static const char T__htm[] PROGMEM = ".htm";
+static const char T__html[] PROGMEM = ".html";
+static const char T__ico[] PROGMEM = ".ico";
+static const char T__jpg[] PROGMEM = ".jpg";
+static const char T__js[] PROGMEM = ".js";
+static const char T__json[] PROGMEM = ".json";
+static const char T__pdf[] PROGMEM = ".pdf";
+static const char T__png[] PROGMEM = ".png";
+static const char T__svg[] PROGMEM = ".svg";
+static const char T__ttf[] PROGMEM = ".ttf";
+static const char T__woff[] PROGMEM = ".woff";
+static const char T__woff2[] PROGMEM = ".woff2";
+static const char T__xml[] PROGMEM = ".xml";
+static const char T__zip[] PROGMEM = ".zip";
+static const char T_application_javascript[] PROGMEM = "application/javascript";
+static const char T_application_json[] PROGMEM = "application/json";
+static const char T_application_msgpack[] PROGMEM = "application/msgpack";
+static const char T_application_pdf[] PROGMEM = "application/pdf";
+static const char T_application_x_gzip[] PROGMEM = "application/x-gzip";
+static const char T_application_zip[] PROGMEM = "application/zip";
+static const char T_font_eot[] PROGMEM = "font/eot";
+static const char T_font_ttf[] PROGMEM = "font/ttf";
+static const char T_font_woff[] PROGMEM = "font/woff";
+static const char T_font_woff2[] PROGMEM = "font/woff2";
+static const char T_image_gif[] PROGMEM = "image/gif";
+static const char T_image_jpeg[] PROGMEM = "image/jpeg";
+static const char T_image_png[] PROGMEM = "image/png";
+static const char T_image_svg_xml[] PROGMEM = "image/svg+xml";
+static const char T_image_x_icon[] PROGMEM = "image/x-icon";
+static const char T_text_css[] PROGMEM = "text/css";
+static const char T_text_event_stream[] PROGMEM = "text/event-stream";
+static const char T_text_html[] PROGMEM = "text/html";
+static const char T_text_plain[] PROGMEM = "text/plain";
+static const char T_text_xml[] PROGMEM = "text/xml";
+
+// Responce codes
+static const char T_HTTP_CODE_100[] PROGMEM = "Continue";
+static const char T_HTTP_CODE_101[] PROGMEM = "Switching Protocols";
+static const char T_HTTP_CODE_200[] PROGMEM = "OK";
+static const char T_HTTP_CODE_201[] PROGMEM = "Created";
+static const char T_HTTP_CODE_202[] PROGMEM = "Accepted";
+static const char T_HTTP_CODE_203[] PROGMEM = "Non-Authoritative Information";
+static const char T_HTTP_CODE_204[] PROGMEM = "No Content";
+static const char T_HTTP_CODE_205[] PROGMEM = "Reset Content";
+static const char T_HTTP_CODE_206[] PROGMEM = "Partial Content";
+static const char T_HTTP_CODE_300[] PROGMEM = "Multiple Choices";
+static const char T_HTTP_CODE_301[] PROGMEM = "Moved Permanently";
+static const char T_HTTP_CODE_302[] PROGMEM = "Found";
+static const char T_HTTP_CODE_303[] PROGMEM = "See Other";
+static const char T_HTTP_CODE_304[] PROGMEM = "Not Modified";
+static const char T_HTTP_CODE_305[] PROGMEM = "Use Proxy";
+static const char T_HTTP_CODE_307[] PROGMEM = "Temporary Redirect";
+static const char T_HTTP_CODE_400[] PROGMEM = "Bad Request";
+static const char T_HTTP_CODE_401[] PROGMEM = "Unauthorized";
+static const char T_HTTP_CODE_402[] PROGMEM = "Payment Required";
+static const char T_HTTP_CODE_403[] PROGMEM = "Forbidden";
+static const char T_HTTP_CODE_404[] PROGMEM = "Not Found";
+static const char T_HTTP_CODE_405[] PROGMEM = "Method Not Allowed";
+static const char T_HTTP_CODE_406[] PROGMEM = "Not Acceptable";
+static const char T_HTTP_CODE_407[] PROGMEM = "Proxy Authentication Required";
+static const char T_HTTP_CODE_408[] PROGMEM = "Request Time-out";
+static const char T_HTTP_CODE_409[] PROGMEM = "Conflict";
+static const char T_HTTP_CODE_410[] PROGMEM = "Gone";
+static const char T_HTTP_CODE_411[] PROGMEM = "Length Required";
+static const char T_HTTP_CODE_412[] PROGMEM = "Precondition Failed";
+static const char T_HTTP_CODE_413[] PROGMEM = "Request Entity Too Large";
+static const char T_HTTP_CODE_414[] PROGMEM = "Request-URI Too Large";
+static const char T_HTTP_CODE_415[] PROGMEM = "Unsupported Media Type";
+static const char T_HTTP_CODE_416[] PROGMEM = "Requested range not satisfiable";
+static const char T_HTTP_CODE_417[] PROGMEM = "Expectation Failed";
+static const char T_HTTP_CODE_500[] PROGMEM = "Internal Server Error";
+static const char T_HTTP_CODE_501[] PROGMEM = "Not Implemented";
+static const char T_HTTP_CODE_502[] PROGMEM = "Bad Gateway";
+static const char T_HTTP_CODE_503[] PROGMEM = "Service Unavailable";
+static const char T_HTTP_CODE_504[] PROGMEM = "Gateway Time-out";
+static const char T_HTTP_CODE_505[] PROGMEM = "HTTP Version not supported";
+static const char T_HTTP_CODE_ANY[] PROGMEM = "Unknown code";
+
+// other
+static const char T__opaque[] PROGMEM = "\", opaque=\"";
+static const char T_13[] PROGMEM = "13";
+static const char T_asyncesp[] PROGMEM = "asyncesp";
+static const char T_auth_nonce[] PROGMEM = "\", qop=\"auth\", nonce=\"";
+static const char T_cnonce[] PROGMEM = "cnonce";
+static const char T_data_[] PROGMEM = "data: ";
+static const char T_event_[] PROGMEM = "event: ";
+static const char T_filename[] PROGMEM = "filename";
+static const char T_gzip[] PROGMEM = "gzip";
+static const char T_Host[] PROGMEM = "Host";
+static const char T_id__[] PROGMEM = "id: ";
+static const char T_name[] PROGMEM = "name";
+static const char T_nc[] PROGMEM = "nc";
+static const char T_nonce[] PROGMEM = "nonce";
+static const char T_opaque[] PROGMEM = "opaque";
+static const char T_qop[] PROGMEM = "qop";
+static const char T_realm[] PROGMEM = "realm";
+static const char T_realm__[] PROGMEM = "realm=\"";
+static const char T_response[] PROGMEM = "response";
+static const char T_retry_[] PROGMEM = "retry: ";
+static const char T_rn[] PROGMEM = "\r\n";
+static const char T_rnrn[] PROGMEM = "\r\n\r\n";
+static const char T_uri[] PROGMEM = "uri";
+static const char T_username[] PROGMEM = "username";
+
+#endif  // ESP8622
+
+}   // namespace asyncsrv {}

lib/ESPAsyncWebServer/src/port/SHA1Builder.cpp

@@ -0,0 +1,284 @@
+/*
+ *  FIPS-180-1 compliant SHA-1 implementation
+ *
+ *  Copyright (C) 2006-2015, ARM Limited, All Rights Reserved
+ *  SPDX-License-Identifier: Apache-2.0
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License"); you may
+ *  not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *  http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ *  WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ *
+ *  This file is part of mbed TLS (https://tls.mbed.org)
+ *  Modified for esp32 by Lucas Saavedra Vaz on 11 Jan 2024
+ */
+
+#include <Arduino.h>
+#if ESP_IDF_VERSION_MAJOR < 5
+
+#include "SHA1Builder.h"
+
+// 32-bit integer manipulation macros (big endian)
+
+#ifndef GET_UINT32_BE
+#define GET_UINT32_BE(n, b, i) \
+  { (n) = ((uint32_t)(b)[(i)] << 24) | ((uint32_t)(b)[(i) + 1] << 16) | ((uint32_t)(b)[(i) + 2] << 8) | ((uint32_t)(b)[(i) + 3]); }
+#endif
+
+#ifndef PUT_UINT32_BE
+#define PUT_UINT32_BE(n, b, i)           \
+  {                                      \
+    (b)[(i)] = (uint8_t)((n) >> 24);     \
+    (b)[(i) + 1] = (uint8_t)((n) >> 16); \
+    (b)[(i) + 2] = (uint8_t)((n) >> 8);  \
+    (b)[(i) + 3] = (uint8_t)((n));       \
+  }
+#endif
+
+// Constants
+
+static const uint8_t sha1_padding[64] = {0x80, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+                                         0,    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
+
+// Private methods
+
+void SHA1Builder::process(const uint8_t *data) {
+  uint32_t temp, W[16], A, B, C, D, E;
+
+  GET_UINT32_BE(W[0], data, 0);
+  GET_UINT32_BE(W[1], data, 4);
+  GET_UINT32_BE(W[2], data, 8);
+  GET_UINT32_BE(W[3], data, 12);
+  GET_UINT32_BE(W[4], data, 16);
+  GET_UINT32_BE(W[5], data, 20);
+  GET_UINT32_BE(W[6], data, 24);
+  GET_UINT32_BE(W[7], data, 28);
+  GET_UINT32_BE(W[8], data, 32);
+  GET_UINT32_BE(W[9], data, 36);
+  GET_UINT32_BE(W[10], data, 40);
+  GET_UINT32_BE(W[11], data, 44);
+  GET_UINT32_BE(W[12], data, 48);
+  GET_UINT32_BE(W[13], data, 52);
+  GET_UINT32_BE(W[14], data, 56);
+  GET_UINT32_BE(W[15], data, 60);
+
+#define sha1_S(x, n) ((x << n) | ((x & 0xFFFFFFFF) >> (32 - n)))
+
+#define sha1_R(t) (temp = W[(t - 3) & 0x0F] ^ W[(t - 8) & 0x0F] ^ W[(t - 14) & 0x0F] ^ W[t & 0x0F], (W[t & 0x0F] = sha1_S(temp, 1)))
+
+#define sha1_P(a, b, c, d, e, x)                      \
+  {                                                   \
+    e += sha1_S(a, 5) + sha1_F(b, c, d) + sha1_K + x; \
+    b = sha1_S(b, 30);                                \
+  }
+
+  A = state[0];
+  B = state[1];
+  C = state[2];
+  D = state[3];
+  E = state[4];
+
+#define sha1_F(x, y, z) (z ^ (x & (y ^ z)))
+#define sha1_K          0x5A827999
+
+  sha1_P(A, B, C, D, E, W[0]);
+  sha1_P(E, A, B, C, D, W[1]);
+  sha1_P(D, E, A, B, C, W[2]);
+  sha1_P(C, D, E, A, B, W[3]);
+  sha1_P(B, C, D, E, A, W[4]);
+  sha1_P(A, B, C, D, E, W[5]);
+  sha1_P(E, A, B, C, D, W[6]);
+  sha1_P(D, E, A, B, C, W[7]);
+  sha1_P(C, D, E, A, B, W[8]);
+  sha1_P(B, C, D, E, A, W[9]);
+  sha1_P(A, B, C, D, E, W[10]);
+  sha1_P(E, A, B, C, D, W[11]);
+  sha1_P(D, E, A, B, C, W[12]);
+  sha1_P(C, D, E, A, B, W[13]);
+  sha1_P(B, C, D, E, A, W[14]);
+  sha1_P(A, B, C, D, E, W[15]);
+  sha1_P(E, A, B, C, D, sha1_R(16));
+  sha1_P(D, E, A, B, C, sha1_R(17));
+  sha1_P(C, D, E, A, B, sha1_R(18));
+  sha1_P(B, C, D, E, A, sha1_R(19));
+
+#undef sha1_K
+#undef sha1_F
+
+#define sha1_F(x, y, z) (x ^ y ^ z)
+#define sha1_K          0x6ED9EBA1
+
+  sha1_P(A, B, C, D, E, sha1_R(20));
+  sha1_P(E, A, B, C, D, sha1_R(21));
+  sha1_P(D, E, A, B, C, sha1_R(22));
+  sha1_P(C, D, E, A, B, sha1_R(23));
+  sha1_P(B, C, D, E, A, sha1_R(24));
+  sha1_P(A, B, C, D, E, sha1_R(25));
+  sha1_P(E, A, B, C, D, sha1_R(26));
+  sha1_P(D, E, A, B, C, sha1_R(27));
+  sha1_P(C, D, E, A, B, sha1_R(28));
+  sha1_P(B, C, D, E, A, sha1_R(29));
+  sha1_P(A, B, C, D, E, sha1_R(30));
+  sha1_P(E, A, B, C, D, sha1_R(31));
+  sha1_P(D, E, A, B, C, sha1_R(32));
+  sha1_P(C, D, E, A, B, sha1_R(33));
+  sha1_P(B, C, D, E, A, sha1_R(34));
+  sha1_P(A, B, C, D, E, sha1_R(35));
+  sha1_P(E, A, B, C, D, sha1_R(36));
+  sha1_P(D, E, A, B, C, sha1_R(37));
+  sha1_P(C, D, E, A, B, sha1_R(38));
+  sha1_P(B, C, D, E, A, sha1_R(39));
+
+#undef sha1_K
+#undef sha1_F
+
+#define sha1_F(x, y, z) ((x & y) | (z & (x | y)))
+#define sha1_K          0x8F1BBCDC
+
+  sha1_P(A, B, C, D, E, sha1_R(40));
+  sha1_P(E, A, B, C, D, sha1_R(41));
+  sha1_P(D, E, A, B, C, sha1_R(42));
+  sha1_P(C, D, E, A, B, sha1_R(43));
+  sha1_P(B, C, D, E, A, sha1_R(44));
+  sha1_P(A, B, C, D, E, sha1_R(45));
+  sha1_P(E, A, B, C, D, sha1_R(46));
+  sha1_P(D, E, A, B, C, sha1_R(47));
+  sha1_P(C, D, E, A, B, sha1_R(48));
+  sha1_P(B, C, D, E, A, sha1_R(49));
+  sha1_P(A, B, C, D, E, sha1_R(50));
+  sha1_P(E, A, B, C, D, sha1_R(51));
+  sha1_P(D, E, A, B, C, sha1_R(52));
+  sha1_P(C, D, E, A, B, sha1_R(53));
+  sha1_P(B, C, D, E, A, sha1_R(54));
+  sha1_P(A, B, C, D, E, sha1_R(55));
+  sha1_P(E, A, B, C, D, sha1_R(56));
+  sha1_P(D, E, A, B, C, sha1_R(57));
+  sha1_P(C, D, E, A, B, sha1_R(58));
+  sha1_P(B, C, D, E, A, sha1_R(59));
+
+#undef sha1_K
+#undef sha1_F
+
+#define sha1_F(x, y, z) (x ^ y ^ z)
+#define sha1_K          0xCA62C1D6
+
+  sha1_P(A, B, C, D, E, sha1_R(60));
+  sha1_P(E, A, B, C, D, sha1_R(61));
+  sha1_P(D, E, A, B, C, sha1_R(62));
+  sha1_P(C, D, E, A, B, sha1_R(63));
+  sha1_P(B, C, D, E, A, sha1_R(64));
+  sha1_P(A, B, C, D, E, sha1_R(65));
+  sha1_P(E, A, B, C, D, sha1_R(66));
+  sha1_P(D, E, A, B, C, sha1_R(67));
+  sha1_P(C, D, E, A, B, sha1_R(68));
+  sha1_P(B, C, D, E, A, sha1_R(69));
+  sha1_P(A, B, C, D, E, sha1_R(70));
+  sha1_P(E, A, B, C, D, sha1_R(71));
+  sha1_P(D, E, A, B, C, sha1_R(72));
+  sha1_P(C, D, E, A, B, sha1_R(73));
+  sha1_P(B, C, D, E, A, sha1_R(74));
+  sha1_P(A, B, C, D, E, sha1_R(75));
+  sha1_P(E, A, B, C, D, sha1_R(76));
+  sha1_P(D, E, A, B, C, sha1_R(77));
+  sha1_P(C, D, E, A, B, sha1_R(78));
+  sha1_P(B, C, D, E, A, sha1_R(79));
+
+#undef sha1_K
+#undef sha1_F
+
+  state[0] += A;
+  state[1] += B;
+  state[2] += C;
+  state[3] += D;
+  state[4] += E;
+}
+
+// Public methods
+
+void SHA1Builder::begin(void) {
+  total[0] = 0;
+  total[1] = 0;
+
+  state[0] = 0x67452301;
+  state[1] = 0xEFCDAB89;
+  state[2] = 0x98BADCFE;
+  state[3] = 0x10325476;
+  state[4] = 0xC3D2E1F0;
+
+  memset(buffer, 0x00, sizeof(buffer));
+  memset(hash, 0x00, sizeof(hash));
+}
+
+void SHA1Builder::add(const uint8_t *data, size_t len) {
+  size_t fill;
+  uint32_t left;
+
+  if (len == 0) {
+    return;
+  }
+
+  left = total[0] & 0x3F;
+  fill = 64 - left;
+
+  total[0] += (uint32_t)len;
+  total[0] &= 0xFFFFFFFF;
+
+  if (total[0] < (uint32_t)len) {
+    total[1]++;
+  }
+
+  if (left && len >= fill) {
+    memcpy((void *)(buffer + left), data, fill);
+    process(buffer);
+    data += fill;
+    len -= fill;
+    left = 0;
+  }
+
+  while (len >= 64) {
+    process(data);
+    data += 64;
+    len -= 64;
+  }
+
+  if (len > 0) {
+    memcpy((void *)(buffer + left), data, len);
+  }
+}
+
+void SHA1Builder::calculate(void) {
+  uint32_t last, padn;
+  uint32_t high, low;
+  uint8_t msglen[8];
+
+  high = (total[0] >> 29) | (total[1] << 3);
+  low = (total[0] << 3);
+
+  PUT_UINT32_BE(high, msglen, 0);
+  PUT_UINT32_BE(low, msglen, 4);
+
+  last = total[0] & 0x3F;
+  padn = (last < 56) ? (56 - last) : (120 - last);
+
+  add((uint8_t *)sha1_padding, padn);
+  add(msglen, 8);
+
+  PUT_UINT32_BE(state[0], hash, 0);
+  PUT_UINT32_BE(state[1], hash, 4);
+  PUT_UINT32_BE(state[2], hash, 8);
+  PUT_UINT32_BE(state[3], hash, 12);
+  PUT_UINT32_BE(state[4], hash, 16);
+}
+
+void SHA1Builder::getBytes(uint8_t *output) {
+  memcpy(output, hash, SHA1_HASH_SIZE);
+}
+
+#endif // ESP_IDF_VERSION_MAJOR < 5

lib/ESPAsyncWebServer/src/port/SHA1Builder.h

@@ -0,0 +1,39 @@
+// Copyright 2024 Espressif Systems (Shanghai) PTE LTD
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#ifndef SHA1Builder_h
+#define SHA1Builder_h
+
+#include <Stream.h>
+#include <WString.h>
+
+#define SHA1_HASH_SIZE 20
+
+class SHA1Builder {
+  private:
+    uint32_t total[2];            /* number of bytes processed  */
+    uint32_t state[5];            /* intermediate digest state  */
+    unsigned char buffer[64];     /* data block being processed */
+    uint8_t hash[SHA1_HASH_SIZE]; /* SHA-1 result               */
+
+    void process(const uint8_t* data);
+
+  public:
+    void begin();
+    void add(const uint8_t* data, size_t len);
+    void calculate();
+    void getBytes(uint8_t* output);
+};
+
+#endif // SHA1Builder_h