Switch HTTP Server

lib/PsychicHttp/CHANGELOG.md

@@ -0,0 +1,34 @@
+# v1.2.1
+
+* Fix bug with missing include preventing the HTTPS server from compiling.
+
+# v1.2
+
+* Added TemplatePrinter from https://github.com/Chris--A/PsychicHttp/tree/templatePrint
+* Support using as ESP IDF component
+* Optional using https server in ESP IDF
+* Fixed bug with headers
+* Add ESP IDF example + CI script
+* Added Arduino Captive Portal example and OTAUpdate from @06GitHub
+* HTTPS fix for ESP-IDF v5.0.2+ from @06GitHub
+* lots of bugfixes from @mathieucarbou
+
+Thanks to @Chris--A, @06GitHub, and @dzungpv for your contributions.
+
+# v1.1
+
+* Changed the internal structure to support request handlers on endpoints and generic requests that do not match an endpoint
+    * websockets, uploads, etc should now create an appropriate handler and attach to an endpoint with the server.on() syntax
+* Added PsychicClient to abstract away some of the internals of ESP-IDF sockets + add convenience
+    * onOpen and onClose callbacks have changed as a result
+* Added support for EventSource / SSE
+* Added support for multipart file uploads
+* changed getParam() to return a PsychicWebParameter in line with ESPAsyncWebserver
+* Renamed various classes / files:
+    * PsychicHttpFileResponse -> PsychicFileResponse
+    * PsychicHttpServerEndpoint -> PsychicEndpoint
+    * PsychicHttpServerRequest -> PsychicRequest
+    * PsychicHttpServerResponse -> PsychicResponse
+    * PsychicHttpWebsocket.h -> PsychicWebSocket.h
+    * Websocket => WebSocket
+* Quite a few bugfixes from the community. Thank you @glennsky, @gb88, @KastanEr, @kstam, and @zekageri

lib/PsychicHttp/CMakeLists.txt

@@ -0,0 +1,19 @@
+set(COMPONENT_SRCDIRS
+    "src"
+)
+
+set(COMPONENT_ADD_INCLUDEDIRS
+    "src"
+)
+
+set(COMPONENT_REQUIRES
+    "arduino-esp32"
+    "esp_https_server"
+    "ArduinoJson"
+    "UrlEncode"
+)
+
+register_component()
+
+target_compile_definitions(${COMPONENT_TARGET} PUBLIC -DESP32)
+target_compile_options(${COMPONENT_TARGET} PRIVATE -fno-rtti)

lib/PsychicHttp/LICENSE

@@ -0,0 +1,7 @@
+Copyright (c) 2024 Jeremy Poulter, Zachary Smith, and Mathieu Carbou
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

lib/PsychicHttp/README.md

@@ -0,0 +1,826 @@
+# PsychicHttp - HTTP on your ESP 🧙🔮
+
+PsychicHttp is a webserver library for ESP32 + Arduino framework which uses the [ESP-IDF HTTP Server](https://docs.espressif.com/projects/esp-idf/en/latest/esp32/api-reference/protocols/esp_http_server.html) library under the hood.  It is written in a similar style to the [Arduino WebServer](https://github.com/espressif/arduino-esp32/tree/master/libraries/WebServer), [ESPAsyncWebServer](https://github.com/me-no-dev/ESPAsyncWebServer), and [ArduinoMongoose](https://github.com/jeremypoulter/ArduinoMongoose) libraries to make writing code simple and porting from those other libraries straightforward.
+
+# Features
+
+* Asynchronous approach (server runs in its own FreeRTOS thread)
+* Handles all HTTP methods with lots of convenience functions:
+    * GET/POST parameters
+    * get/set headers
+    * get/set cookies
+    * basic key/value session data storage
+    * authentication (basic and digest mode)
+* HTTPS / SSL support
+* Static fileserving (SPIFFS, LittleFS, etc.)
+* Chunked response serving for large files
+* File uploads (Basic + Multipart)
+* Websocket support with onOpen, onFrame, and onClose callbacks
+* EventSource / SSE support with onOpen, and onClose callbacks
+* Request filters, including Client vs AP mode (ON_STA_FILTER / ON_AP_FILTER)
+* TemplatePrinter class for dynamic variables at runtime
+
+## Differences from ESPAsyncWebserver
+
+* No templating system (anyone actually use this?)
+* No url rewriting (but you can use request->redirect)
+
+# Usage
+
+## Installation
+
+### Platformio
+
+[PlatformIO](http://platformio.org) is an open source ecosystem for IoT development.
+
+ Add "PsychicHttp" to project using [Project Configuration File `platformio.ini`](http://docs.platformio.org/page/projectconf.html) and [lib_deps](http://docs.platformio.org/page/projectconf/section_env_library.html#lib-deps) option:
+
+```ini
+[env:myboard]
+platform = espressif...
+board = ...
+framework = arduino
+
+# using the latest stable version
+lib_deps = hoeken/PsychicHttp
+
+# or using GIT Url (the latest development version)
+lib_deps = https://github.com/hoeken/PsychicHttp
+```
+
+### Installation - Arduino
+
+Open *Tools -> Manage Libraries...* and search for PsychicHttp.
+
+# Principles of Operation
+
+## Things to Note
+
+* PsychicHttp is a fully asynchronous server and as such does not run on the loop thread.
+* You should not use yield or delay or any function that uses them inside the callbacks.
+* The server is smart enough to know when to close the connection and free resources.
+* You can not send more than one response to a single request.
+
+## PsychicHttp
+
+* Listens for connections.
+* Wraps the incoming request into PsychicRequest.
+* Keeps track of clients + calls optional callbacks on client open and close.
+* Find the appropriate handler (if any) for a request and pass it on.
+
+## Request Life Cycle
+
+* TCP connection is received by the server.
+* HTTP request is wrapped inside ```PsychicRequest``` object + TCP Connection wrapped inside PsychicConnection object.
+* When the request head is received, the server goes through all ```PsychicEndpoints``` and finds one that matches the url + method.
+    * ```handler->filter()``` and ```handler->canHandle()``` are called on the handler to verify the handler should process the request.
+    * ```handler->needsAuthentication()``` is called and sends an authorization response if required.
+    * ```handler->handleRequest()``` is called to actually process the HTTP request.
+* If the handler cannot process the request, the server will loop through any global handlers and call that handler if it passes filter(), canHandle(), and needsAuthentication().
+* If no global handlers are called, the server.defaultEndpoint handler will be called.
+* Each handler is responsible for processing the request and sending a response.
+* When the response is sent, the client is closed and freed from the memory.
+    * Unless its a special handler like websockets or eventsource.
+
+![Flowchart of Request Lifecycle](/assets/request-flow.svg)
+
+### Handlers
+
+* ```PsychicHandler``` is used for processing and responding to specific HTTP requests.
+* ```PsychicHandler``` instances can be attached to any endpoint or as global handlers.
+* Setting a ```Filter``` to the ```PsychicHandler``` controls when to apply the handler, decision can be based on
+  request method, url, request host/port/target host, the request client's localIP or remoteIP.
+* Two filter callbacks are provided: ```ON_AP_FILTER``` to execute the rewrite when request is made to the AP interface,
+  ```ON_STA_FILTER``` to execute the rewrite when request is made to the STA interface.
+* The ```canHandle``` method is used for handler specific control on whether the requests can be handled. Decision can be based on request method, request url, request host/port/target host.
+* Depending on how the handler is implemented, it may provide callbacks for adding your own custom processing code to the handler.
+* Global ```Handlers``` are evaluated in the order they are attached to the server. The ```canHandle``` is called only
+  if the ```Filter``` that was set to the ```Handler``` return true.
+* The first global ```Handler``` that can handle the request is selected, no further processing of handlers is called.
+
+![Flowchart of Request Lifecycle](/assets/handler-callbacks.svg)
+
+### Responses and how do they work
+
+* The ```PsychicResponse``` objects are used to send the response data back to the client.
+* Typically the response should be fully generated and sent from the callback.
+* It may be possible to generate the response outside the callback, but it will be difficult.
+   * The exceptions are websockets + eventsource where the response is sent, but the connection is maintained and new data can be sent/received outside the handler.
+
+# Porting From ESPAsyncWebserver
+
+If you have existing code using ESPAsyncWebserver, you will feel right at home with PsychicHttp.  Even if internally it is much different, the external interface is very similar.  Some things are mostly cosmetic, like different class names and callback definitions.  A few things might require a bit more in-depth approach.  If you're porting your code and run into issues that aren't covered here, please post and issue.
+
+## Globals Stuff
+
+* Change your #include to ```#include <PsychicHttp.h>```
+* Change your server instance: ```PsychicHttpServer server;```
+* Define websocket handler if you have one: ```PsychicWebSocketHandler websocketHandler;```
+* Define eventsource if you have one: ```PsychicEventSource eventSource;```
+
+## setup() Stuff
+
+* no more server.begin(), call server.listen(80), before you add your handlers
+* server has a configurable limit on .on() endpoints. change it with ```server.config.max_uri_handlers = 20;``` as needed.
+* check your callback function definitions:
+   * AsyncWebServerRequest -> PsychicRequest
+   * no more onBody() event
+      * for small bodies (server.maxRequestBodySize, default 16k) it will be automatically loaded and accessed by request->body()
+      * for large bodies, use an upload handler and onUpload()   
+   * websocket callbacks are much different (and simpler!)
+   * websocket / eventsource handlers get attached to url in server.on("/url", &handler) instead of passing url to handler constructor.
+   * eventsource callbacks are onOpen and onClose now.
+* HTTP_ANY is not supported by ESP-IDF, so we can't use it either.
+* NO server.onFileUpload(onUpload); (you could attach an UploadHandler to the default endpoint i guess?)
+* NO server.onRequestBody(onBody); (same)
+
+## Requests / Responses
+
+* request->send is now request->reply()
+* if you create a response, call response->send() directly, not request->send(reply)
+* request->headers() is not supported by ESP-IDF, you have to just check for the header you need.
+* No AsyncCallbackJsonWebHandler (for now... can add if needed)
+* No request->beginResponse().  Instanciate a PsychicResponse instead: ```PsychicResponse response(request);```
+* No PROGMEM suppport (its not relevant to ESP32: https://esp32.com/viewtopic.php?t=20595)
+* No Stream response support just yet
+
+# Usage
+
+## Create the Server
+
+Here is an example of the typical server setup:
+
+```cpp
+#include <PsychicHttp.h>
+PsychicHttpServer server;
+
+void setup()
+{
+   //optional low level setup server config stuff here.
+   //server.config is an ESP-IDF httpd_config struct
+   //see: https://docs.espressif.com/projects/esp-idf/en/v4.4.6/esp32/api-reference/protocols/esp_http_server.html#_CPPv412httpd_config
+   //increase maximum number of uri endpoint handlers (.on() calls)
+   server.config.max_uri_handlers = 20; 
+
+   //connect to wifi
+
+   //start the server listening on port 80 (standard HTTP port)
+   server.listen(80);
+
+   //call server methods to attach endpoints and handlers
+   server.on(...);
+   server.serveStatic(...);
+   server.attachHandler(...);
+}
+```
+
+## Add Handlers
+
+One major difference from ESPAsyncWebserver is that handlers can be attached to a specific url (endpoint) or as a global handler.  The reason for this, is that attaching to a specific URL is more efficient and makes for cleaner code.
+
+### Endpoint Handlers
+
+An endpoint is basically just the URL path (eg. /path/to/file) without any query string.  The ```server.on(...)``` function is a convenience function for creating endpoints and attaching a handler to them.  There are two main styles: attaching a basic ```WebRequest``` handler and attaching an external handler.
+
+```cpp
+//creates a basic PsychicWebHandler that calls the request_callback callback
+server.on("/url", HTTP_GET, request_callback);
+
+//same as above, but defaults to HTTP_GET
+server.on("/url", request_callback);
+
+//attaches a websocket handler to /ws
+PsychicWebSocketHandler websocketHandler;
+server.on("/ws", &websocketHandler);
+```
+
+The ```server.on(...)``` returns a pointer to the endpoint, which can be used to call various functions like ```setHandler()```, ```setFilter()```, and ```setAuthentication()```.
+
+```cpp
+//respond to /url only from requests to the AP
+server.on("/url", HTTP_GET, request_callback)->setFilter(ON_AP_FILTER);
+
+//require authentication on /url
+server.on("/url", HTTP_GET, request_callback)->setAuthentication("user", "pass");
+
+//attach websocket handler to /ws
+PsychicWebSocketHandler websocketHandler;
+server.on("/ws")->attachHandler(&websocketHandler);
+```
+
+### Basic Requests
+
+The ```PsychicWebHandler``` class is for handling standard web requests.  It provides a single callback: ```onRequest()```.  This callback is called when the handler receives a valid HTTP request.
+
+One major difference from ESPAsyncWebserver is that this callback needs to return an esp_err_t variable to let the server know the result of processing the request.  The ```response->reply()``` and ```request->send()``` functions will return this.  It is a good habit to return the result of these functions as sending the response will close the connection.
+
+The function definition for the onRequest callback is:
+
+```cpp
+esp_err_t function_name(PsychicRequest *request);
+```
+
+Here is a simple example that sends back the client's IP on the URL /ip
+
+```cpp
+server.on("/ip", [](PsychicRequest *request)
+{
+   String output = "Your IP is: " + request->client()->remoteIP().toString();
+   return request->reply(output.c_str());
+});
+```
+
+### Uploads
+
+The ```PsychicUploadHandler``` class is for handling uploads, both large POST bodies and multipart encoded forms.  It provides two callbacks: ```onUpload()``` and ```onRequest()```.
+
+```onUpload(...)``` is called when there is new data.  This function may be called multiple times so that you can process the data in chunks. The function definition for the onUpload callback is:
+
+```cpp
+esp_err_t function_name(PsychicRequest *request, const String& filename, uint64_t index, uint8_t *data, size_t len, bool final);
+```
+
+* request is a pointer to the Request object
+* filename is the name of the uploaded file
+* index is the overall byte position of the current data
+* data is a pointer to the data buffer
+* len is the length of the data buffer
+* final is a flag to tell if its the last chunk of data
+
+```onRequest(...)``` is called after the successful handling of the upload.  Its definition and usage is the same as the basic request example as above.
+
+#### Basic Upload (file is the entire POST body)
+
+It's worth noting that there is no standard way of passing in a filename for this method, so the handler attempts to guess the filename with the following methods:
+
+* Checking the Content-Disposition header
+* Checking the _filename query parameter (eg. /upload?filename=filename.txt becomes filename.txt)
+* Checking the url and taking the last part as filename (eg. /upload/filename.txt becomes filename.txt).  You must set a wildcard url for this to work as in the example below.
+
+```cpp
+//handle a very basic upload as post body
+ PsychicUploadHandler *uploadHandler = new PsychicUploadHandler();
+ uploadHandler->onUpload([](PsychicRequest *request, const String& filename, uint64_t index, uint8_t *data, size_t len, bool last) {
+   File file;
+   String path = "/www/" + filename;
+
+   Serial.printf("Writing %d/%d bytes to: %s\n", (int)index+(int)len, request->contentLength(), path.c_str());
+
+   if (last)
+     Serial.printf("%s is finished. Total bytes: %d\n", path.c_str(), (int)index+(int)len);
+
+   //our first call?
+   if (!index)
+     file = LittleFS.open(path, FILE_WRITE);
+   else
+     file = LittleFS.open(path, FILE_APPEND);
+   
+   if(!file) {
+     Serial.println("Failed to open file");
+     return ESP_FAIL;
+   }
+
+   if(!file.write(data, len)) {
+     Serial.println("Write failed");
+     return ESP_FAIL;
+   }
+
+   return ESP_OK;
+ });
+
+ //gets called after upload has been handled
+ uploadHandler->onRequest([](PsychicRequest *request)
+ {
+   String url = "/" + request->getFilename();
+   String output = "<a href=\"" + url + "\">" + url + "</a>";
+
+   return request->reply(output.c_str());
+ });
+
+ //wildcard basic file upload - POST to /upload/filename.ext
+ server.on("/upload/*", HTTP_POST, uploadHandler);
+```
+
+#### Multipart Upload
+
+Very similar to the basic upload, with 2 key differences:
+
+* multipart requests don't know the total size of the file until after it has been fully processed.  You can get a rough idea with request->contentLength(), but that is the length of the entire multipart encoded request.
+* you can access form variables, including multipart file infor (name + size) in the onRequest handler using request->getParam()
+
+```cpp
+ //a little bit more complicated multipart form
+ PsychicUploadHandler *multipartHandler = new PsychicUploadHandler();
+ multipartHandler->onUpload([](PsychicRequest *request, const String& filename, uint64_t index, uint8_t *data, size_t len, bool last) {
+   File file;
+   String path = "/www/" + filename;
+
+   //some progress over serial.
+   Serial.printf("Writing %d bytes to: %s\n", (int)len, path.c_str());
+   if (last)
+     Serial.printf("%s is finished. Total bytes: %d\n", path.c_str(), (int)index+(int)len);
+
+   //our first call?
+   if (!index)
+     file = LittleFS.open(path, FILE_WRITE);
+   else
+     file = LittleFS.open(path, FILE_APPEND);
+   
+   if(!file) {
+     Serial.println("Failed to open file");
+     return ESP_FAIL;
+   }
+
+   if(!file.write(data, len)) {
+     Serial.println("Write failed");
+     return ESP_FAIL;
+   }
+
+   return ESP_OK;
+ });
+
+ //gets called after upload has been handled
+ multipartHandler->onRequest([](PsychicRequest *request)
+ {
+   PsychicWebParameter *file = request->getParam("file_upload");
+
+   String url = "/" + file->value();
+   String output;
+
+   output += "<a href=\"" + url + "\">" + url + "</a><br/>\n";
+   output += "Bytes: " + String(file->size()) + "<br/>\n";
+   output += "Param 1: " + request->getParam("param1")->value() + "<br/>\n";
+   output += "Param 2: " + request->getParam("param2")->value() + "<br/>\n";
+   
+   return request->reply(output.c_str());
+ });
+
+ //upload to /multipart url
+ server.on("/multipart", HTTP_POST, multipartHandler);
+```
+
+### Static File Serving
+
+The ```PsychicStaticFileHandler``` is a special handler that does not provide any callbacks.  It is used to serve a file or files from a specific directory in a filesystem to a directory on the webserver.  The syntax is exactly the same as ESPAsyncWebserver. Anything that is derived from the ```FS``` class should work (eg. SPIFFS, LittleFS, SD, etc)
+
+A couple important notes:
+
+* If it finds a file with an extra .gz extension, it will serve it as gzip encoded (eg: /targetfile.ext -> {targetfile.ext}.gz)
+* If the file is larger than FILE_CHUNK_SIZE (default 8kb) then it will send it as a chunked response.
+* It will detect most basic filetypes and automatically set the appropriate Content-Type
+
+The ```server.serveStatic()``` function handles creating the handler and assigning it to the server:
+
+```cpp
+//serve static files from LittleFS/www on / only to clients on same wifi network
+//this is where our /index.html file lives
+server.serveStatic("/", LittleFS, "/www/")->setFilter(ON_STA_FILTER);
+
+//serve static files from LittleFS/www-ap on / only to clients on SoftAP
+//this is where our /index.html file lives
+server.serveStatic("/", LittleFS, "/www-ap/")->setFilter(ON_AP_FILTER);
+
+//serve static files from LittleFS/img on /img
+//it's more efficient to serve everything from a single www directory, but this is also possible.
+server.serveStatic("/img", LittleFS, "/img/");
+
+//you can also serve single files
+server.serveStatic("/myfile.txt", LittleFS, "/custom.txt");
+```
+
+You could also theoretically use the file response directly:
+
+```cpp
+server.on("/ip", [](PsychicRequest *request)
+{
+   String filename = "/path/to/file";
+   PsychicFileResponse response(request, LittleFS, filename);
+
+   return response.send();
+});
+PsychicFileResponse(PsychicRequest *request, FS &fs, const String& path)
+```
+
+### Websockets
+
+The ```PsychicWebSocketHandler``` class is for handling WebSocket connections.  It provides 3 callbacks:
+
+```onOpen(...)``` is called when a new WebSocket client connects.
+```onFrame(...)``` is called when a new WebSocket frame has arrived.
+```onClose(...)``` is called when a new WebSocket client disconnects.
+
+Here are the callback definitions:
+
+```cpp
+void open_function(PsychicWebSocketClient *client);
+esp_err_t frame_function(PsychicWebSocketRequest *request, httpd_ws_frame *frame);
+void close_function(PsychicWebSocketClient *client);
+```
+
+WebSockets were the main reason for starting PsychicHttp, so they are well tested.  They are also much simplified from the ESPAsyncWebserver style.  You do not need to worry about error handling, partial frame assembly, PONG messages, etc.  The onFrame() function is called when a complete frame has been received, and can handle frames up to the entire available heap size.
+
+Here is a basic example of using WebSockets:
+
+```cpp
+ //create our handler... note this should be located as a global or somewhere it wont go out of scope and be destroyed.
+ PsychicWebSocketHandler websocketHandler();
+
+ websocketHandler.onOpen([](PsychicWebSocketClient *client) {
+   Serial.printf("[socket] connection #%u connected from %s\n", client->socket(), client->remoteIP().toString());
+   client->sendMessage("Hello!");
+ });
+
+ websocketHandler.onFrame([](PsychicWebSocketRequest *request, httpd_ws_frame *frame) {
+     Serial.printf("[socket] #%d sent: %s\n", request->client()->socket(), (char *)frame->payload);
+     return request->reply(frame);
+ });
+
+ websocketHandler.onClose([](PsychicWebSocketClient *client) {
+   Serial.printf("[socket] connection #%u closed from %s\n", client->socket(), client->remoteIP().toString());
+ });
+
+ //attach the handler to /ws.  You can then connect to ws://ip.address/ws
+ server.on("/ws", &websocketHandler);
+```
+
+The onFrame() callback has 2 parameters:
+
+* ```PsychicWebSocketRequest *request``` a special request with helper functions for replying in websocket format.
+* ```httpd_ws_frame *frame``` ESP-IDF websocket struct.  The important struct members we care about are:
+   * ```uint8_t *payload; /*!< Pre-allocated data buffer */```
+   * ```size_t len; /*!< Length of the WebSocket data */```
+ 
+For sending data on the websocket connection, there are 3 methods:
+
+* ```request->reply()``` - only available in the onFrame() callback context.
+* ```webSocketHandler.sendAll()``` - can be used anywhere to send websocket messages to all connected clients.
+* ```client->send()``` - can be used anywhere* to send a websocket message to a specific client
+
+All of the above functions either accept simple ```char *``` string of you can construct your own httpd_ws_frame.
+
+*Special Note:*  Do not hold on to the ```PsychicWebSocketClient``` for sending messages to clients outside the callbacks. That pointer is destroyed when a client disconnects.  Instead, store the ```int client->socket()```.  Then when you want to send a message, use this code:
+
+```cpp
+//make sure our client is still connected.
+PsychicWebSocketClient *client = websocketHandler.getClient(socket);
+if (client != NULL)
+  client->send("Your Message")
+```
+
+### EventSource / SSE
+
+The ```PsychicEventSource``` class is for handling EventSource / SSE connections.  It provides 2 callbacks:
+
+```onOpen(...)``` is called when a new EventSource client connects.
+```onClose(...)``` is called when a new EventSource client disconnects.
+
+Here are the callback definitions:
+
+```cpp
+void open_function(PsychicEventSourceClient *client);
+void close_function(PsychicEventSourceClient *client);
+```
+
+Here is a basic example of using PsychicEventSource:
+
+```cpp
+ //create our handler... note this should be located as a global or somewhere it wont go out of scope and be destroyed.
+ PsychicEventSource eventSource;
+
+ eventSource.onOpen([](PsychicEventSourceClient *client) {
+   Serial.printf("[eventsource] connection #%u connected from %s\n", client->socket(), client->remoteIP().toString());
+   client->send("Hello user!", NULL, millis(), 1000);
+ });
+
+ eventSource.onClose([](PsychicEventSourceClient *client) {
+   Serial.printf("[eventsource] connection #%u closed from %s\n", client->socket(), client->remoteIP().toString());
+ });
+
+ //attach the handler to /events
+ server.on("/events", &eventSource);
+```
+
+For sending data on the EventSource connection, there are 2 methods:
+
+* ```eventSource.send()``` - can be used anywhere to send events to all connected clients.
+* ```client->send()``` - can be used anywhere* to send events to a specific client
+
+All of the above functions accept a simple ```char *``` message, and optionally: ```char *``` event name, id, and reconnect time.
+
+*Special Note:*  Do not hold on to the ```PsychicEventSourceClient``` for sending messages to clients outside the callbacks. That pointer is destroyed when a client disconnects.  Instead, store the ```int client->socket()```.  Then when you want to send a message, use this code:
+
+```cpp
+//make sure our client is still connected.
+PsychicEventSourceClient *client = eventSource.getClient(socket);
+if (client != NULL)
+  client->send("Your Event")
+```
+
+### HTTPS / SSL
+
+PsychicHttp supports HTTPS / SSL out of the box, however there are some limitations (see performance below).  Enabling it also increases the code size by about 100kb.  To use HTTPS, you need to modify your setup like so:
+
+```cpp
+#include <PsychicHttp.h>
+#include <PsychicHttpsServer.h>
+PsychicHttpsServer server;
+server.listen(443, server_cert, server_key);
+```
+
+```server_cert``` and ```server_key``` are both ```const char *``` parameters which contain the server certificate and private key, respectively.
+
+To generate your own key and self signed certificate, you can use the command below:
+
+```
+openssl req -x509 -newkey rsa:4096 -nodes -keyout server.key -out server.crt -sha256 -days 365
+```
+
+Including the ```PsychicHttpsServer.h``` also defines ```PSY_ENABLE_SSL``` which you can use in your code to allow enabling / disabling calls in your code based on if the HTTPS server is available:
+
+```cpp
+//our main server object
+#ifdef PSY_ENABLE_SSL
+  PsychicHttpsServer server;
+#else
+  PsychicHttpServer server;
+#endif
+```
+
+Last, but not least, you can create a separate HTTP server on port 80 that redirects all requests to the HTTPS server:
+
+```cpp
+//this creates a 2nd server listening on port 80 and redirects all requests HTTPS
+PsychicHttpServer *redirectServer = new PsychicHttpServer();
+redirectServer->config.ctrl_port = 20420; // just a random port different from the default one
+redirectServer->listen(80);
+redirectServer->onNotFound([](PsychicRequest *request) {
+   String url = "https://" + request->host() + request->url();
+   return request->redirect(url.c_str());
+});
+```
+
+# TemplatePrinter
+
+**This is not specific to PsychicHttp, and it works with any `Print` object. You could for example, template data out to `File`, `Serial`, etc...**.
+
+The template engine is a `Print` interface and can be printed to directly, however,  if you are just templating a few short strings, I'd probably just use `response.printf()` instead. **Its benefit will be seen when templating large inputs such as files.**
+
+One benefit may be **templating a **JSON** file avoiding the need to use ArduinoJson.**
+
+Before closing the underlying `Print`/`Stream` that this writes to, it must be flushed as small amounts of data can be buffered. A convenience method to take care of this is shows in `example 3`.
+
+The header file is not currently added to `PsychicHttp.h` and users will have to add it manually:
+
+```C++
+#include <TemplatePrinter.h>
+```
+ 
+## Template parameter definition:
+
+- Must start and end with a preset delimiter, the default is `%`
+- Can only contain `a-z`, `A-Z`, `0-9`, and `_`
+- Maximum length of 63 characters (buffer is 64 including `null`).
+- A parameter must not be zero length (not including delimiters).
+- Spaces or any other character do not match as a parameter, and will be output as is.
+- Valid examples
+  - `%MY_PARAM%`
+  - `%SOME1%`
+- **Invalid** examples
+  - `%MY PARAM%`
+  - `%SOME1 %`
+  - `%UNFINISHED`
+  - `%%`
+
+## Template processing
+A function or lambda is used to receive the parameter replacement.
+
+```C++
+bool templateHandler(Print &output, const char *param){
+  //...
+}
+
+[](Print &output, const char *param){
+  //...
+}
+```
+
+Parameters:
+- `Print &output` - the underlying `Print`, print the results of templating to this.
+- `const char *param` - a string containing the current parameter.
+
+The handler must return a `bool`.
+- `true`: the parameter was handled, continue as normal.
+- `false`: the input detected as a parameter is not, print literal.
+
+See output in **example 1** regarding the effects of returning `true` or `false`.
+
+## Template input handler
+This is not needed unless using the static convenience function `TemplatePrinter::start()`. See **example 3**.
+
+```C++
+bool inputHandler(TemplatePrinter &printer){
+  //...
+}
+
+[](TemplatePrinter &printer){
+  //...
+}
+```
+
+Parameters:
+- `TemplatePrinter &printer` - The template engine, print your template text to this for processing.
+
+
+## Example 1 - Simple use with `PsychicStreamResponse`:
+This example highlights its most basic usage.
+
+```C++
+
+//  Function to handle parameter requests.
+
+bool templateHandler(Print &output, const char *param){
+
+  if(strcmp(param, "FREE_HEAP") == 0){
+    output.print((double)ESP.getFreeHeap() / 1024.0, 2);
+
+  }else if(strcmp(param, "MIN_FREE_HEAP") == 0){
+    output.print((double)ESP.getMinFreeHeap() / 1024.0, 2);
+
+  }else if(strcmp(param, "MAX_ALLOC_HEAP") == 0){
+    output.print((double)ESP.getMaxAllocHeap() / 1024.0, 2);
+    
+  }else if(strcmp(param, "HEAP_SIZE") == 0){
+    output.print((double)ESP.getHeapSize() / 1024.0, 2);
+  }else{
+    return false;
+  }
+  output.print("Kb");
+  return true;
+}
+
+//  Example serving a request
+server.on("/template", [](PsychicRequest *request) {
+  PsychicStreamResponse response(request, "text/plain");
+
+  response.beginSend();
+  
+  TemplatePrinter printer(response, templateHandler);
+
+  printer.println("My ESP has %FREE_HEAP% left. Its lifetime minimum heap is %MIN_FREE_HEAP%.");
+  printer.println("The maximum allocation size is %MAX_ALLOC_HEAP%, and its total size is %HEAP_SIZE%.");
+  printer.println("This is an unhandled parameter: %UNHANDLED_PARAM% and this is an invalid param %INVALID PARAM%.");
+  printer.println("This line finished with %UNFIN");
+  printer.flush();
+
+  return response.endSend();
+});   
+```
+
+The output for example looks like:
+```
+My ESP has 170.92Kb left. Its lifetime minimum heap is 169.83Kb.
+The maximum allocation size is 107.99Kb, and its total size is 284.19Kb.
+This is an unhandled parameter: %UNHANDLED_PARAM% and this is an invalid param %INVALID PARAM%.
+This line finished with %UNFIN
+```
+
+## Example 2 - Templating a file
+
+```C++
+server.on("/home", [](PsychicRequest *request) {
+  PsychicStreamResponse response(request, "text/html");
+  File file = SD.open("/www/index.html");
+
+  response.beginSend();
+
+  TemplatePrinter printer(response, templateHandler);
+
+  printer.copyFrom(file);
+  printer.flush();
+  file.close();
+
+  return response.endSend();
+}); 
+```
+
+## Example 3 - Using the `TemplatePrinter::start` method.
+This static method allows an RAII approach, allowing you to template a stream, etc... without needing a `flush()`. The function call is laid out as:
+
+```C++
+TemplatePrinter::start(host_stream, template_handler, input_handler);
+```
+
+\*these examples use the `templateHandler` function defined in example 1.
+
+### Serve a file like example 2
+```C++
+server.on("/home", [](PsychicRequest *request) {
+  PsychicStreamResponse response(request, "text/html");
+  File file = SD.open("/www/index.html");
+
+  response.beginSend();
+  TemplatePrinter::start(response, templateHandler, [&file](TemplatePrinter &printer){
+    printer.copyFrom(file);
+  });
+  file.close();
+
+  return response.endSend();
+});
+```
+
+### Template a string like example 1
+```C++
+server.on("/template2", [](PsychicRequest *request) {
+
+  PsychicStreamResponse response(request, "text/plain");
+
+  response.beginSend();
+
+  TemplatePrinter::start(response, templateHandler, [](TemplatePrinter &printer){
+    printer.println("My ESP has %FREE_HEAP% left. Its lifetime minimum heap is %MIN_FREE_HEAP%.");
+    printer.println("The maximum allocation size is %MAX_ALLOC_HEAP%, and its total size is %HEAP_SIZE%.");
+    printer.println("This is an unhandled parameter: %UNHANDLED_PARAM% and this is an invalid param %INVALID PARAM%.");
+  });
+
+  return response.endSend();
+});
+```
+
+# Performance
+
+In order to really see the differences between libraries, I created some basic benchmark firmwares for PsychicHttp, ESPAsyncWebserver, and ArduinoMongoose.  I then ran the loadtest-http.sh and loadtest-websocket.sh scripts against each firmware to get some real numbers on the performance of each server library.  All of the code and results are available in the /benchmark folder.  If you want to see the collated data and graphs, there is a [LibreOffice spreadsheet](/benchmark/comparison.ods).
+
+![Performance graph](/benchmark/performance.png)
+![Latency graph](/benchmark/latency.png)
+
+## HTTPS / SSL
+
+Yes, PsychicHttp supports SSL out of the box, but there are a few caveats:
+
+* Due to memory limitations, it can only handle 2 connections at a time. Each SSL connection takes about 45k ram, and a blank PsychicHttp sketch has about 150k ram free.
+* Speed and latency are still pretty good (see graph above) but the SSH handshake seems to take 1500ms.  With websockets or browser its not an issue since the connection is kept alive, but if you are loading requests in another way it will be a bit slow
+* Unless you want to expose your ESP to the internet, you are limited to self signed keys and the annoying browser security warnings that come with them.
+
+## Analysis
+
+The results clearly show some of the reasons for writing PsychicHttp: ESPAsyncWebserver crashes under heavy load on each test, across the board in a 60s test.  That means in normal usage, you're just rolling the dice with how long it will go until it crashes.  Every other number is moot, IMHO.
+
+ArduinoMongoose doesn't crash under heavy load, but it does bog down with extremely high latency (15s) for web requests and appears to not even respond at the highest loadings as the loadtest script crashes instead.  The code itself doesnt crash, so bonus points there.  After the high load, it does go back to serving normally.  One area ArduinoMongoose does shine, is in websockets where its performance is almost 2x the performance of PsychicHttp.  Both in requests per second and latency.  Clearly an area of improvement for PsychicHttp.
+
+PsychicHttp has good performance across the board.  No crashes and continously responds during each test.  It is a clear winner in requests per second when serving files from memory, dynamic JSON, and has consistent performance when serving files from LittleFS. The only real downside is the lower performance of the websockets with a single connection handling 38rps, and maxing out at 120rps across multiple connections.
+
+## Takeaways
+
+With all due respect to @me-no-dev who has done some amazing work in the open source community, I cannot recommend anyone use the ESPAsyncWebserver for anything other than simple projects that don't need to be reliable.  Even then, PsychicHttp has taken the arcane api of the ESP-IDF web server library and made it nice and friendly to use with a very similar API to ESPAsyncWebserver.  Also, ESPAsyncWebserver is more or less abandoned, with 150 open issues, 77 pending pull requests, and the last commit in over 2 years.
+
+ArduinoMongoose is a good alternative, although the latency issues when it gets fully loaded can be very annoying. I believe it is also cross platform to other microcontrollers as well, but I haven't tested that. The other issue here is that it is based on an old version of a modified Mongoose library that will be difficult to update as it is a major revision behind and several security updates behind as well.  Big thanks to @jeremypoulter though as PsychicHttp is a fork of ArduinoMongoose so it's built on strong bones.
+
+# Roadmap
+
+## v1.2: ESPAsyncWebserver Parity
+
+
+Change:
+Modify the request handling to bring initail url matching and filtering into PsychicHttpServer itself.
+
+Benefits: 
+* Fix a bug with filter() where endpoint is matched, but filter fails and it doesn't continue matching further endpoints (checks are in different codebases)
+* HTTP_ANY support
+* unlimited endpoints
+  * we would use a List to store endpoints
+  * dont have to pre-declare config.max_uri_handlers;
+* much more flexibility for future
+
+Issues
+* it would log a warning on every request as if its a 404. (httpd_uri.c:298)
+* req->user_ctx is not passed in. (httpd_uri.c:309)
+    * but... user_ctx is something we could store in the psychicendpoint data
+  * Websocket support assumes an endpoint with matching url / method (httpd_uri.c:312)
+    * we could copy and bring this code into our own internal request processor
+  * would need to manually maintain more code (~100 lines?) and be more prone to esp-idf http_server updates causing problems.
+
+How to implement
+* set config.max_uri_handlers = 1;
+* possibly do not register any uri_handlers (looks like it would be fastest way to exit httpd_find_uri_handler (httpd_uri.c:94))
+  * looks like 404 is set by default, so should work.
+* modify PsychicEndpoint to store the stuff we would pass to http_server
+* create a new function handleRequest() before PsychicHttpServer::defaultNotFoundHandler to process incoming requests.
+  * bring in code from PsychicHttpServer::notFoundHandler
+  * add new code to loop over endpoints to call match and filter
+* bring code from esp-idf library
+
+* templating system
+* regex url matching
+* rewrite urls?
+* What else are we missing?
+
+
+## Longterm Wants
+
+* investigate websocket performance gap
+* support for esp-idf framework
+* support for arduino 3.0 framework
+* Enable worker based multithreading with esp-idf v5.x
+* 100-continue support?
+     
+If anyone wants to take a crack at implementing any of the above features I am more than happy to accept pull requests.

lib/PsychicHttp/RELEASE.md

@@ -0,0 +1,6 @@
+* Update CHANGELOG
+* Bump version in library.json
+* Bump version in library.properties
+* Make new release + tag
+	* this will get pulled in automatically by Arduino Library Indexer
+* run ```pio pkg publish``` to publish to Platform.io

lib/PsychicHttp/benchmark/arduinomongoose/.gitignore

@@ -0,0 +1,6 @@
+.pio
+.vscode/
+.vscode/.browse.c_cpp.db*
+.vscode/c_cpp_properties.json
+.vscode/launch.json
+.vscode/ipch

lib/PsychicHttp/benchmark/arduinomongoose/include/README

@@ -0,0 +1,39 @@
+
+This directory is intended for project header files.
+
+A header file is a file containing C declarations and macro definitions
+to be shared between several project source files. You request the use of a
+header file in your project source file (C, C++, etc) located in `src` folder
+by including it, with the C preprocessing directive `#include'.
+
+```src/main.c
+
+#include "header.h"
+
+int main (void)
+{
+ ...
+}
+```
+
+Including a header file produces the same results as copying the header file
+into each source file that needs it. Such copying would be time-consuming
+and error-prone. With a header file, the related declarations appear
+in only one place. If they need to be changed, they can be changed in one
+place, and programs that include the header file will automatically use the
+new version when next recompiled. The header file eliminates the labor of
+finding and changing all the copies as well as the risk that a failure to
+find one copy will result in inconsistencies within a program.
+
+In C, the usual convention is to give header files names that end with `.h'.
+It is most portable to use only letters, digits, dashes, and underscores in
+header file names, and at most one dot.
+
+Read more about using header files in official GCC documentation:
+
+* Include Syntax
+* Include Operation
+* Once-Only Headers
+* Computed Includes
+
+https://gcc.gnu.org/onlinedocs/cpp/Header-Files.html

lib/PsychicHttp/benchmark/arduinomongoose/lib/README

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

lib/PsychicHttp/benchmark/arduinomongoose/platformio.ini

@@ -0,0 +1,22 @@
+; PlatformIO Project Configuration File
+;
+;   Build options: build flags, source filter
+;   Upload options: custom upload port, speed and extra flags
+;   Library options: dependencies, extra library storages
+;   Advanced options: extra scripting
+;
+; Please visit documentation for the other options and examples
+; https://docs.platformio.org/page/projectconf.html
+
+[env]
+platform = espressif32
+framework = arduino
+board = esp32dev
+monitor_speed = 115200
+monitor_filters = esp32_exception_decoder
+lib_deps = 
+    jeremypoulter/ArduinoMongoose
+    bblanchon/ArduinoJson
+board_build.filesystem = littlefs
+
+[env:default]

lib/PsychicHttp/benchmark/arduinomongoose/src/main.cpp

@@ -0,0 +1,234 @@
+/* Wi-Fi STA Connect and Disconnect Example
+
+   This example code is in the Public Domain (or CC0 licensed, at your option.)
+
+   Unless required by applicable law or agreed to in writing, this
+   software is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
+   CONDITIONS OF ANY KIND, either express or implied.
+
+*/
+#include <Arduino.h>
+#include <WiFi.h>
+#include <MongooseCore.h>
+#include <MongooseHttpServer.h>
+#include <LittleFS.h>
+#include <ArduinoJSON.h>
+
+const char *ssid = "";
+const char *password = "";
+
+MongooseHttpServer server;
+
+const char *htmlContent = R"(
+<!DOCTYPE html>
+<html>
+<head>
+    <title>Sample HTML</title>
+</head>
+<body>
+    <h1>Hello, World!</h1>
+    <p>Lorem ipsum dolor sit amet, consectetur adipiscing elit. Proin euismod, purus a euismod
+    rhoncus, urna ipsum cursus massa, eu dictum tellus justo ac justo. Quisque ullamcorper
+    arcu nec tortor ullamcorper, vel fermentum justo fermentum. Vivamus sed velit ut elit
+    accumsan congue ut ut enim. Ut eu justo eu lacus varius gravida ut a tellus. Nulla facilisi.
+    Integer auctor consectetur ultricies. Fusce feugiat, mi sit amet bibendum viverra, orci leo
+    dapibus elit, id varius sem dui id lacus.</p>
+    <p>Lorem ipsum dolor sit amet, consectetur adipiscing elit. Proin euismod, purus a euismod
+    rhoncus, urna ipsum cursus massa, eu dictum tellus justo ac justo. Quisque ullamcorper
+    arcu nec tortor ullamcorper, vel fermentum justo fermentum. Vivamus sed velit ut elit
+    accumsan congue ut ut enim. Ut eu justo eu lacus varius gravida ut a tellus. Nulla facilisi.
+    Integer auctor consectetur ultricies. Fusce feugiat, mi sit amet bibendum viverra, orci leo
+    dapibus elit, id varius sem dui id lacus.</p>
+    <p>Lorem ipsum dolor sit amet, consectetur adipiscing elit. Proin euismod, purus a euismod
+    rhoncus, urna ipsum cursus massa, eu dictum tellus justo ac justo. Quisque ullamcorper
+    arcu nec tortor ullamcorper, vel fermentum justo fermentum. Vivamus sed velit ut elit
+    accumsan congue ut ut enim. Ut eu justo eu lacus varius gravida ut a tellus. Nulla facilisi.
+    Integer auctor consectetur ultricies. Fusce feugiat, mi sit amet bibendum viverra, orci leo
+    dapibus elit, id varius sem dui id lacus.</p>
+    <p>Lorem ipsum dolor sit amet, consectetur adipiscing elit. Proin euismod, purus a euismod
+    rhoncus, urna ipsum cursus massa, eu dictum tellus justo ac justo. Quisque ullamcorper
+    arcu nec tortor ullamcorper, vel fermentum justo fermentum. Vivamus sed velit ut elit
+    accumsan congue ut ut enim. Ut eu justo eu lacus varius gravida ut a tellus. Nulla facilisi.
+    Integer auctor consectetur ultricies. Fusce feugiat, mi sit amet bibendum viverra, orci leo
+    dapibus elit, id varius sem dui id lacus.</p>
+    <p>Lorem ipsum dolor sit amet, consectetur adipiscing elit. Proin euismod, purus a euismod
+    rhoncus, urna ipsum cursus massa, eu dictum tellus justo ac justo. Quisque ullamcorper
+    arcu nec tortor ullamcorper, vel fermentum justo fermentum. Vivamus sed velit ut elit
+    accumsan congue ut ut enim. Ut eu justo eu lacus varius gravida ut a tellus. Nulla facilisi.
+    Integer auctor consectetur ultricies. Fusce feugiat, mi sit amet bibendum viverra, orci leo
+    dapibus elit, id varius sem dui id lacus.</p>
+    <p>Lorem ipsum dolor sit amet, consectetur adipiscing elit. Proin euismod, purus a euismod
+    rhoncus, urna ipsum cursus massa, eu dictum tellus justo ac justo. Quisque ullamcorper
+    arcu nec tortor ullamcorper, vel fermentum justo fermentum. Vivamus sed velit ut elit
+    accumsan congue ut ut enim. Ut eu justo eu lacus varius gravida ut a tellus. Nulla facilisi.
+    Integer auctor consectetur ultricies. Fusce feugiat, mi sit amet bibendum viverra, orci leo
+    dapibus elit, id varius sem dui id lacus.</p>
+    <p>Lorem ipsum dolor sit amet, consectetur adipiscing elit. Proin euismod, purus a euismod
+    rhoncus, urna ipsum cursus massa, eu dictum tellus justo ac justo. Quisque ullamcorper
+    arcu nec tortor ullamcorper, vel fermentum justo fermentum. Vivamus sed velit ut elit
+    accumsan congue ut ut enim. Ut eu justo eu lacus varius gravida ut a tellus. Nulla facilisi.
+    Integer auctor consectetur ultricies. Fusce feugiat, mi sit amet bibendum viverra, orci leo
+    dapibus elit, id varius sem dui id lacus.</p>
+    <p>Lorem ipsum dolor sit amet, consectetur adipiscing elit. Proin euismod, purus a euismod
+    rhoncus, urna ipsum cursus massa, eu dictum tellus justo ac justo. Quisque ullamcorper
+    arcu nec tortor ullamcorper, vel fermentum justo fermentum. Vivamus sed velit ut elit
+    accumsan congue ut ut enim. Ut eu justo eu lacus varius gravida ut a tellus. Nulla facilisi.
+    Integer auctor consectetur ultricies. Fusce feugiat, mi sit amet bibendum viverra, orci leo
+    dapibus elit, id varius sem dui id lacus.</p>
+</body>
+</html>
+)";
+
+bool connectToWifi()
+{
+  Serial.println();
+  Serial.print("[WiFi] Connecting to ");
+  Serial.println(ssid);
+
+  WiFi.setSleep(false);
+  WiFi.useStaticBuffers(true);
+
+  WiFi.begin(ssid, password);
+
+  // Will try for about 10 seconds (20x 500ms)
+  int tryDelay = 500;
+  int numberOfTries = 20;
+
+  // Wait for the WiFi event
+  while (true)
+  {
+    switch (WiFi.status())
+    {
+      case WL_NO_SSID_AVAIL:
+        Serial.println("[WiFi] SSID not found");
+        break;
+      case WL_CONNECT_FAILED:
+        Serial.print("[WiFi] Failed - WiFi not connected! Reason: ");
+        return false;
+        break;
+      case WL_CONNECTION_LOST:
+        Serial.println("[WiFi] Connection was lost");
+        break;
+      case WL_SCAN_COMPLETED:
+        Serial.println("[WiFi] Scan is completed");
+        break;
+      case WL_DISCONNECTED:
+        Serial.println("[WiFi] WiFi is disconnected");
+        break;
+      case WL_CONNECTED:
+        Serial.println("[WiFi] WiFi is connected!");
+        Serial.print("[WiFi] IP address: ");
+        Serial.println(WiFi.localIP());
+        return true;
+        break;
+      default:
+        Serial.print("[WiFi] WiFi Status: ");
+        Serial.println(WiFi.status());
+        break;
+    }
+    delay(tryDelay);
+
+    if (numberOfTries <= 0)
+    {
+      Serial.print("[WiFi] Failed to connect to WiFi!");
+      // Use disconnect function to force stop trying to connect
+      WiFi.disconnect();
+      return false;
+    }
+    else
+    {
+      numberOfTries--;
+    }
+  }
+
+  return false;
+}
+
+void setup()
+{
+  Serial.begin(115200);
+  delay(10);
+  Serial.println("ArduinoMongoose Benchmark");
+
+  // We start by connecting to a WiFi network
+  // To debug, please enable Core Debug Level to Verbose
+  if (connectToWifi())
+  {
+    if(!LittleFS.begin())
+    {
+      Serial.println("LittleFS Mount Failed. Do Platform -> Build Filesystem Image and Platform -> Upload Filesystem Image from VSCode");
+      return;
+    }
+
+    //start our server
+    Mongoose.begin();
+    server.begin(80);
+
+    //index file
+    server.on("/", HTTP_GET, [](MongooseHttpServerRequest *request)
+    {      
+      request->send(200, "text/html", htmlContent);
+    });
+
+    //api - parameters passed in via query eg. /api/endpoint?foo=bar
+    server.on("/api", HTTP_GET, [](MongooseHttpServerRequest *request)
+    {
+      //create a response object
+      StaticJsonDocument<128> output;
+      output["msg"] = "status";
+      output["status"] = "success";
+      output["millis"] = millis();
+
+      //work with some params
+      if (request->hasParam("foo"))
+      {
+        String foo = request->getParam("foo");
+        output["foo"] = foo;
+      }
+
+      //serialize and return
+      String jsonBuffer;
+      serializeJson(output, jsonBuffer);
+      request->send(200, "application/json", jsonBuffer.c_str());
+    });
+
+    //websocket
+    server.on("/ws$")->
+    onFrame([](MongooseHttpWebSocketConnection *connection, int flags, uint8_t *data, size_t len) {
+      connection->send(WEBSOCKET_OP_TEXT, data, len);
+      //server.sendAll(connection, (char *)data);
+    });
+
+    //hack - no servestatic
+    server.on("/alien.png", HTTP_GET, [](MongooseHttpServerRequest *request)
+    {
+      //open our file
+      File fp = LittleFS.open("/www/alien.png");
+      size_t length = fp.size();
+
+      //read our data
+      uint8_t * data = (uint8_t *)malloc(length);
+      if (data != NULL)
+      {
+        fp.readBytes((char *)data, length);
+
+        //send it off
+        MongooseHttpServerResponseBasic *response = request->beginResponse();
+        response->setContent(data, length);
+        response->setContentType("image/png");
+        response->setCode(200);
+        request->send(response);
+
+        //free the memory
+        free(data);
+      }
+      else
+        request->send(503);
+    });
+  }
+}
+
+void loop()
+{
+  Mongoose.poll(1000);
+}

lib/PsychicHttp/benchmark/arduinomongoose/test/README

@@ -0,0 +1,11 @@
+
+This directory is intended for PlatformIO Test Runner and project tests.
+
+Unit Testing is a software testing method by which individual units of
+source code, sets of one or more MCU program modules together with associated
+control data, usage procedures, and operating procedures, are tested to
+determine whether they are fit for use. Unit testing finds problems early
+in the development cycle.
+
+More information about PlatformIO Unit Testing:
+- https://docs.platformio.org/en/latest/advanced/unit-testing/index.html

lib/PsychicHttp/benchmark/espasyncwebserver/.gitignore

@@ -0,0 +1,6 @@
+.pio
+.vscode/
+.vscode/.browse.c_cpp.db*
+.vscode/c_cpp_properties.json
+.vscode/launch.json
+.vscode/ipch

lib/PsychicHttp/benchmark/espasyncwebserver/include/README

@@ -0,0 +1,39 @@
+
+This directory is intended for project header files.
+
+A header file is a file containing C declarations and macro definitions
+to be shared between several project source files. You request the use of a
+header file in your project source file (C, C++, etc) located in `src` folder
+by including it, with the C preprocessing directive `#include'.
+
+```src/main.c
+
+#include "header.h"
+
+int main (void)
+{
+ ...
+}
+```
+
+Including a header file produces the same results as copying the header file
+into each source file that needs it. Such copying would be time-consuming
+and error-prone. With a header file, the related declarations appear
+in only one place. If they need to be changed, they can be changed in one
+place, and programs that include the header file will automatically use the
+new version when next recompiled. The header file eliminates the labor of
+finding and changing all the copies as well as the risk that a failure to
+find one copy will result in inconsistencies within a program.
+
+In C, the usual convention is to give header files names that end with `.h'.
+It is most portable to use only letters, digits, dashes, and underscores in
+header file names, and at most one dot.
+
+Read more about using header files in official GCC documentation:
+
+* Include Syntax
+* Include Operation
+* Once-Only Headers
+* Computed Includes
+
+https://gcc.gnu.org/onlinedocs/cpp/Header-Files.html

lib/PsychicHttp/benchmark/espasyncwebserver/lib/README

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

lib/PsychicHttp/benchmark/espasyncwebserver/platformio.ini

@@ -0,0 +1,22 @@
+; PlatformIO Project Configuration File
+;
+;   Build options: build flags, source filter
+;   Upload options: custom upload port, speed and extra flags
+;   Library options: dependencies, extra library storages
+;   Advanced options: extra scripting
+;
+; Please visit documentation for the other options and examples
+; https://docs.platformio.org/page/projectconf.html
+
+[env]
+platform = espressif32
+framework = arduino
+board = esp32dev
+monitor_speed = 115200
+monitor_filters = esp32_exception_decoder
+lib_deps = 
+	https://github.com/me-no-dev/ESPAsyncWebServer
+    bblanchon/ArduinoJson
+board_build.filesystem = littlefs
+
+[env:default]

lib/PsychicHttp/benchmark/espasyncwebserver/src/main.cpp

@@ -0,0 +1,276 @@
+/* Wi-Fi STA Connect and Disconnect Example
+
+   This example code is in the Public Domain (or CC0 licensed, at your option.)
+
+   Unless required by applicable law or agreed to in writing, this
+   software is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
+   CONDITIONS OF ANY KIND, either express or implied.
+
+*/
+#include <Arduino.h>
+#include <WiFi.h>
+#include <ESPAsyncWebServer.h>
+#include <LittleFS.h>
+#include <ArduinoJSON.h>
+
+const char *ssid = "";
+const char *password = "";
+
+AsyncWebServer server(80);
+AsyncWebSocket ws("/ws");
+
+const char *htmlContent = R"(
+<!DOCTYPE html>
+<html>
+<head>
+    <title>Sample HTML</title>
+</head>
+<body>
+    <h1>Hello, World!</h1>
+    <p>Lorem ipsum dolor sit amet, consectetur adipiscing elit. Proin euismod, purus a euismod
+    rhoncus, urna ipsum cursus massa, eu dictum tellus justo ac justo. Quisque ullamcorper
+    arcu nec tortor ullamcorper, vel fermentum justo fermentum. Vivamus sed velit ut elit
+    accumsan congue ut ut enim. Ut eu justo eu lacus varius gravida ut a tellus. Nulla facilisi.
+    Integer auctor consectetur ultricies. Fusce feugiat, mi sit amet bibendum viverra, orci leo
+    dapibus elit, id varius sem dui id lacus.</p>
+    <p>Lorem ipsum dolor sit amet, consectetur adipiscing elit. Proin euismod, purus a euismod
+    rhoncus, urna ipsum cursus massa, eu dictum tellus justo ac justo. Quisque ullamcorper
+    arcu nec tortor ullamcorper, vel fermentum justo fermentum. Vivamus sed velit ut elit
+    accumsan congue ut ut enim. Ut eu justo eu lacus varius gravida ut a tellus. Nulla facilisi.
+    Integer auctor consectetur ultricies. Fusce feugiat, mi sit amet bibendum viverra, orci leo
+    dapibus elit, id varius sem dui id lacus.</p>
+    <p>Lorem ipsum dolor sit amet, consectetur adipiscing elit. Proin euismod, purus a euismod
+    rhoncus, urna ipsum cursus massa, eu dictum tellus justo ac justo. Quisque ullamcorper
+    arcu nec tortor ullamcorper, vel fermentum justo fermentum. Vivamus sed velit ut elit
+    accumsan congue ut ut enim. Ut eu justo eu lacus varius gravida ut a tellus. Nulla facilisi.
+    Integer auctor consectetur ultricies. Fusce feugiat, mi sit amet bibendum viverra, orci leo
+    dapibus elit, id varius sem dui id lacus.</p>
+    <p>Lorem ipsum dolor sit amet, consectetur adipiscing elit. Proin euismod, purus a euismod
+    rhoncus, urna ipsum cursus massa, eu dictum tellus justo ac justo. Quisque ullamcorper
+    arcu nec tortor ullamcorper, vel fermentum justo fermentum. Vivamus sed velit ut elit
+    accumsan congue ut ut enim. Ut eu justo eu lacus varius gravida ut a tellus. Nulla facilisi.
+    Integer auctor consectetur ultricies. Fusce feugiat, mi sit amet bibendum viverra, orci leo
+    dapibus elit, id varius sem dui id lacus.</p>
+    <p>Lorem ipsum dolor sit amet, consectetur adipiscing elit. Proin euismod, purus a euismod
+    rhoncus, urna ipsum cursus massa, eu dictum tellus justo ac justo. Quisque ullamcorper
+    arcu nec tortor ullamcorper, vel fermentum justo fermentum. Vivamus sed velit ut elit
+    accumsan congue ut ut enim. Ut eu justo eu lacus varius gravida ut a tellus. Nulla facilisi.
+    Integer auctor consectetur ultricies. Fusce feugiat, mi sit amet bibendum viverra, orci leo
+    dapibus elit, id varius sem dui id lacus.</p>
+    <p>Lorem ipsum dolor sit amet, consectetur adipiscing elit. Proin euismod, purus a euismod
+    rhoncus, urna ipsum cursus massa, eu dictum tellus justo ac justo. Quisque ullamcorper
+    arcu nec tortor ullamcorper, vel fermentum justo fermentum. Vivamus sed velit ut elit
+    accumsan congue ut ut enim. Ut eu justo eu lacus varius gravida ut a tellus. Nulla facilisi.
+    Integer auctor consectetur ultricies. Fusce feugiat, mi sit amet bibendum viverra, orci leo
+    dapibus elit, id varius sem dui id lacus.</p>
+    <p>Lorem ipsum dolor sit amet, consectetur adipiscing elit. Proin euismod, purus a euismod
+    rhoncus, urna ipsum cursus massa, eu dictum tellus justo ac justo. Quisque ullamcorper
+    arcu nec tortor ullamcorper, vel fermentum justo fermentum. Vivamus sed velit ut elit
+    accumsan congue ut ut enim. Ut eu justo eu lacus varius gravida ut a tellus. Nulla facilisi.
+    Integer auctor consectetur ultricies. Fusce feugiat, mi sit amet bibendum viverra, orci leo
+    dapibus elit, id varius sem dui id lacus.</p>
+    <p>Lorem ipsum dolor sit amet, consectetur adipiscing elit. Proin euismod, purus a euismod
+    rhoncus, urna ipsum cursus massa, eu dictum tellus justo ac justo. Quisque ullamcorper
+    arcu nec tortor ullamcorper, vel fermentum justo fermentum. Vivamus sed velit ut elit
+    accumsan congue ut ut enim. Ut eu justo eu lacus varius gravida ut a tellus. Nulla facilisi.
+    Integer auctor consectetur ultricies. Fusce feugiat, mi sit amet bibendum viverra, orci leo
+    dapibus elit, id varius sem dui id lacus.</p>
+</body>
+</html>
+)";
+
+bool connectToWifi()
+{
+  Serial.println();
+  Serial.print("[WiFi] Connecting to ");
+  Serial.println(ssid);
+
+  WiFi.setSleep(false);
+  WiFi.useStaticBuffers(true);
+
+  WiFi.begin(ssid, password);
+
+  // Will try for about 10 seconds (20x 500ms)
+  int tryDelay = 500;
+  int numberOfTries = 20;
+
+  // Wait for the WiFi event
+  while (true)
+  {
+    switch (WiFi.status())
+    {
+      case WL_NO_SSID_AVAIL:
+        Serial.println("[WiFi] SSID not found");
+        break;
+      case WL_CONNECT_FAILED:
+        Serial.print("[WiFi] Failed - WiFi not connected! Reason: ");
+        return false;
+        break;
+      case WL_CONNECTION_LOST:
+        Serial.println("[WiFi] Connection was lost");
+        break;
+      case WL_SCAN_COMPLETED:
+        Serial.println("[WiFi] Scan is completed");
+        break;
+      case WL_DISCONNECTED:
+        Serial.println("[WiFi] WiFi is disconnected");
+        break;
+      case WL_CONNECTED:
+        Serial.println("[WiFi] WiFi is connected!");
+        Serial.print("[WiFi] IP address: ");
+        Serial.println(WiFi.localIP());
+        return true;
+        break;
+      default:
+        Serial.print("[WiFi] WiFi Status: ");
+        Serial.println(WiFi.status());
+        break;
+    }
+    delay(tryDelay);
+
+    if (numberOfTries <= 0)
+    {
+      Serial.print("[WiFi] Failed to connect to WiFi!");
+      // Use disconnect function to force stop trying to connect
+      WiFi.disconnect();
+      return false;
+    }
+    else
+    {
+      numberOfTries--;
+    }
+  }
+
+  return false;
+}
+
+void onEvent(AsyncWebSocket * server, AsyncWebSocketClient * client, AwsEventType type, void * arg, uint8_t *data, size_t len){
+  if(type == WS_EVT_CONNECT){
+    //client connected
+    // Serial.printf("ws[%s][%u] connect\n", server->url(), client->id());
+    // client->printf("Hello Client %u :)", client->id());
+    // client->ping();
+  } else if(type == WS_EVT_DISCONNECT){
+    //client disconnected
+    // Serial.printf("ws[%s][%u] disconnect: %u\n", server->url(), client->id());
+  } else if(type == WS_EVT_ERROR){
+    //error was received from the other end
+    // Serial.printf("ws[%s][%u] error(%u): %s\n", server->url(), client->id(), *((uint16_t*)arg), (char*)data);
+  } else if(type == WS_EVT_PONG){
+    //pong message was received (in response to a ping request maybe)
+    // Serial.printf("ws[%s][%u] pong[%u]: %s\n", server->url(), client->id(), len, (len)?(char*)data:"");
+  } else if(type == WS_EVT_DATA){
+    //data packet
+    AwsFrameInfo * info = (AwsFrameInfo*)arg;
+    if(info->final && info->index == 0 && info->len == len){
+      //the whole message is in a single frame and we got all of it's data
+      // Serial.printf("ws[%s][%u] %s-message[%llu]: ", server->url(), client->id(), (info->opcode == WS_TEXT)?"text":"binary", info->len);
+      if(info->opcode == WS_TEXT){
+        data[len] = 0;
+        // Serial.printf("%s\n", (char*)data);
+      } else {
+        // for(size_t i=0; i < info->len; i++){
+        //   Serial.printf("%02x ", data[i]);
+        // }
+        // Serial.printf("\n");
+      }
+      if(info->opcode == WS_TEXT)
+      {
+        client->text((char *)data, len);
+      }
+      // else
+      //   client->binary("I got your binary message");
+    } else {
+      //message is comprised of multiple frames or the frame is split into multiple packets
+      if(info->index == 0){
+        // if(info->num == 0)
+        //   Serial.printf("ws[%s][%u] %s-message start\n", server->url(), client->id(), (info->message_opcode == WS_TEXT)?"text":"binary");
+        // Serial.printf("ws[%s][%u] frame[%u] start[%llu]\n", server->url(), client->id(), info->num, info->len);
+      }
+
+      Serial.printf("ws[%s][%u] frame[%u] %s[%llu - %llu]: ", server->url(), client->id(), info->num, (info->message_opcode == WS_TEXT)?"text":"binary", info->index, info->index + len);
+      if(info->message_opcode == WS_TEXT){
+        data[len] = 0;
+        // Serial.printf("%s\n", (char*)data);
+      } else {
+        // for(size_t i=0; i < len; i++){
+        //   Serial.printf("%02x ", data[i]);
+        // }
+        // Serial.printf("\n");
+      }
+
+      if((info->index + len) == info->len){
+        // Serial.printf("ws[%s][%u] frame[%u] end[%llu]\n", server->url(), client->id(), info->num, info->len);
+        if(info->final){
+          // Serial.printf("ws[%s][%u] %s-message end\n", server->url(), client->id(), (info->message_opcode == WS_TEXT)?"text":"binary");
+          if(info->message_opcode == WS_TEXT)
+          {
+            client->text((char *)data, info->len);
+          }
+          // else
+          //   client->binary("I got your binary message");
+        }
+      }
+    }
+  }
+}
+
+void setup()
+{
+  Serial.begin(115200);
+  delay(10);
+  Serial.println("ESPAsyncWebserver Benchmark");
+
+  // We start by connecting to a WiFi network
+  // To debug, please enable Core Debug Level to Verbose
+  if (connectToWifi())
+  {
+    if(!LittleFS.begin())
+    {
+      Serial.println("LittleFS Mount Failed. Do Platform -> Build Filesystem Image and Platform -> Upload Filesystem Image from VSCode");
+      return;
+    }
+
+    //api - parameters passed in via query eg. /api/endpoint?foo=bar
+    server.on("/", HTTP_GET, [](AsyncWebServerRequest *request)
+    {
+      request->send(200, "text/html", htmlContent);
+    });
+
+    //serve static files from LittleFS/www on /
+    server.serveStatic("/", LittleFS, "/www/");
+
+    //api - parameters passed in via query eg. /api/endpoint?foo=bar
+    server.on("/api", HTTP_GET, [](AsyncWebServerRequest *request)
+    {
+      //create a response object
+      StaticJsonDocument<128> output;
+      output["msg"] = "status";
+      output["status"] = "success";
+      output["millis"] = millis();
+
+      //work with some params
+      if (request->hasParam("foo"))
+      {
+        AsyncWebParameter* foo = request->getParam("foo");
+        output["foo"] = foo->value();
+      }
+
+      //serialize and return
+      String jsonBuffer;
+      serializeJson(output, jsonBuffer);
+      request->send(200, "application/json", jsonBuffer.c_str());
+    });
+
+    ws.onEvent(onEvent);
+    server.addHandler(&ws);
+
+    server.begin();
+  }
+}
+
+void loop()
+{
+  ws.cleanupClients();
+  delay(1000);
+}

lib/PsychicHttp/benchmark/espasyncwebserver/test/README

@@ -0,0 +1,11 @@
+
+This directory is intended for PlatformIO Test Runner and project tests.
+
+Unit Testing is a software testing method by which individual units of
+source code, sets of one or more MCU program modules together with associated
+control data, usage procedures, and operating procedures, are tested to
+determine whether they are fit for use. Unit testing finds problems early
+in the development cycle.
+
+More information about PlatformIO Unit Testing:
+- https://docs.platformio.org/en/latest/advanced/unit-testing/index.html

lib/PsychicHttp/benchmark/eventsource-client-test.js

@@ -0,0 +1,39 @@
+#!/usr/bin/env node
+
+const EventSource = require('eventsource');
+const url = 'http://192.168.2.131/events';
+
+async function eventSourceClient() {
+  console.log(`Starting test`);
+  for (let i = 0; i < 1000000; i++)
+  {
+    if (i % 100 == 0)
+      console.log(`Count: ${i}`);
+
+    let eventSource = new EventSource(url);
+
+    eventSource.onopen = () => {
+        //console.log('EventSource connection opened.');
+    };
+    
+    eventSource.onerror = (error) => {
+        console.error('EventSource error:', error);
+        
+        // Close the connection on error
+        eventSource.close();
+    };
+
+    await new Promise((resolve) => {
+        eventSource.onmessage = (event) => {
+            //console.log('Received message:', event.data);
+        
+            // Close the connection after receiving the first message
+            eventSource.close();
+    
+            resolve();
+        }
+    });  
+  }
+}
+
+eventSourceClient();

lib/PsychicHttp/benchmark/http-client-test.js

@@ -0,0 +1,43 @@
+#!/usr/bin/env node
+
+const axios = require('axios');
+
+const url = 'http://192.168.2.131/api';
+const queryParams = {
+  foo: 'bar',
+  foo1: 'bar',
+  foo2: 'bar',
+  foo3: 'bar',
+  foo4: 'bar',
+  foo5: 'bar',
+  foo6: 'bar',
+};
+
+const totalRequests = 1000000;
+const requestsPerCount = 100;
+
+let requestCount = 0;
+
+function fetchData() {
+  axios.get(url, { params: queryParams })
+    .then(response => {
+      requestCount++;
+
+      if (requestCount % requestsPerCount === 0) {
+        console.log(`Requests completed: ${requestCount}`);
+      }
+
+      if (requestCount < totalRequests) {
+        fetchData();
+      } else {
+        console.log('All requests completed.');
+      }
+    })
+    .catch(error => {
+      console.error('Error making request:', error.message);
+    });
+}
+
+// Start making requests
+console.log(`Starting test`);
+fetchData();

lib/PsychicHttp/benchmark/loadtest-http.sh

@@ -0,0 +1,37 @@
+#!/usr/bin/env bash
+#Command to install the testers:
+# npm install -g autocannon
+
+TEST_IP="192.168.2.131"
+TEST_TIME=60
+LOG_FILE=psychic-http-loadtest.log
+TIMEOUT=10000
+PROTOCOL=http
+#PROTOCOL=https
+
+if test -f "$LOG_FILE"; then
+  rm $LOG_FILE
+fi
+
+for CONCURRENCY in 1 2 3 4 5 6 7 8 9 10 15 20
+#for CONCURRENCY in 20
+do
+  printf "\n\nCLIENTS: *** $CONCURRENCY ***\n\n" >> $LOG_FILE
+  echo "Testing $CONCURRENCY clients on $PROTOCOL://$TEST_IP/"
+  #loadtest -c $CONCURRENCY --cores 1 -t $TEST_TIME --timeout $TIMEOUT "$PROTOCOL://$TEST_IP/" --quiet >> $LOG_FILE
+  autocannon -c $CONCURRENCY -w 1 -d $TEST_TIME --renderStatusCodes "$PROTOCOL://$TEST_IP/" >> $LOG_FILE 2>&1
+  printf "\n\n----------------\n\n" >> $LOG_FILE
+  sleep 1
+
+  echo "Testing $CONCURRENCY clients on $PROTOCOL://$TEST_IP/api"
+  #loadtest -c $CONCURRENCY --cores 1 -t $TEST_TIME --timeout $TIMEOUT "$PROTOCOL://$TEST_IP/api?foo=bar" --quiet >> $LOG_FILE
+  autocannon -c $CONCURRENCY -w 1 -d $TEST_TIME --renderStatusCodes "$PROTOCOL://$TEST_IP/api?foo=bar" >> $LOG_FILE 2>&1
+  printf "\n\n----------------\n\n" >> $LOG_FILE
+  sleep 1
+  
+  echo "Testing $CONCURRENCY clients on $PROTOCOL://$TEST_IP/alien.png"
+  #loadtest -c $CONCURRENCY --cores 1 -t $TEST_TIME --timeout $TIMEOUT "$PROTOCOL://$TEST_IP/alien.png" --quiet >> $LOG_FILE
+  autocannon -c $CONCURRENCY -w 1 -d $TEST_TIME --renderStatusCodes "$PROTOCOL://$TEST_IP/alien.png" >> $LOG_FILE 2>&1
+  printf "\n\n----------------\n\n" >> $LOG_FILE
+  sleep 1
+done

lib/PsychicHttp/benchmark/loadtest-websocket.sh

@@ -0,0 +1,31 @@
+#!/usr/bin/env bash
+#Command to install the testers:
+# npm install -g loadtest
+
+TEST_IP="192.168.2.131"
+TEST_TIME=60
+LOG_FILE=psychic-websocket-loadtest.log
+PROTOCOL=ws
+#PROTOCOL=wss
+
+if test -f "$LOG_FILE"; then
+  rm $LOG_FILE
+fi
+
+for CONCURRENCY in 1 2 3 4 5 6 7
+do
+  printf "\n\nCLIENTS: *** $CONCURRENCY ***\n\n" >> $LOG_FILE
+  echo "Testing $CONCURRENCY clients on $PROTOCOL://$TEST_IP/ws"
+  loadtest -c $CONCURRENCY --cores 1 -t $TEST_TIME --insecure $PROTOCOL://$TEST_IP/ws --quiet  2> /dev/null >> $LOG_FILE
+  sleep 1
+done
+
+for CONNECTIONS in 8 10 16 20
+#for CONNECTIONS in 20
+do
+  CONCURRENCY=$((CONNECTIONS / 2))
+  printf "\n\nCLIENTS: *** $CONNECTIONS ***\n\n" >> $LOG_FILE
+  echo "Testing $CONNECTIONS clients on $PROTOCOL://$TEST_IP/ws"
+  loadtest -c $CONCURRENCY --cores 2 -t $TEST_TIME --insecure $PROTOCOL://$TEST_IP/ws --quiet 2> /dev/null >> $LOG_FILE
+  sleep 1
+done

lib/PsychicHttp/benchmark/package.json

@@ -0,0 +1,7 @@
+{
+  "dependencies": {
+    "axios": "^1.6.2",
+    "eventsource": "^2.0.2",
+    "ws": "^8.14.2"
+  }
+}

lib/PsychicHttp/benchmark/psychichttp/.gitignore

@@ -0,0 +1,6 @@
+.pio
+.vscode/
+.vscode/.browse.c_cpp.db*
+.vscode/c_cpp_properties.json
+.vscode/launch.json
+.vscode/ipch

lib/PsychicHttp/benchmark/psychichttp/include/README

@@ -0,0 +1,39 @@
+
+This directory is intended for project header files.
+
+A header file is a file containing C declarations and macro definitions
+to be shared between several project source files. You request the use of a
+header file in your project source file (C, C++, etc) located in `src` folder
+by including it, with the C preprocessing directive `#include'.
+
+```src/main.c
+
+#include "header.h"
+
+int main (void)
+{
+ ...
+}
+```
+
+Including a header file produces the same results as copying the header file
+into each source file that needs it. Such copying would be time-consuming
+and error-prone. With a header file, the related declarations appear
+in only one place. If they need to be changed, they can be changed in one
+place, and programs that include the header file will automatically use the
+new version when next recompiled. The header file eliminates the labor of
+finding and changing all the copies as well as the risk that a failure to
+find one copy will result in inconsistencies within a program.
+
+In C, the usual convention is to give header files names that end with `.h'.
+It is most portable to use only letters, digits, dashes, and underscores in
+header file names, and at most one dot.
+
+Read more about using header files in official GCC documentation:
+
+* Include Syntax
+* Include Operation
+* Once-Only Headers
+* Computed Includes
+
+https://gcc.gnu.org/onlinedocs/cpp/Header-Files.html

lib/PsychicHttp/benchmark/psychichttp/lib/README

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

lib/PsychicHttp/benchmark/psychichttp/platformio.ini

@@ -0,0 +1,22 @@
+; PlatformIO Project Configuration File
+;
+;   Build options: build flags, source filter
+;   Upload options: custom upload port, speed and extra flags
+;   Library options: dependencies, extra library storages
+;   Advanced options: extra scripting
+;
+; Please visit documentation for the other options and examples
+; https://docs.platformio.org/page/projectconf.html
+
+[env]
+platform = espressif32
+framework = arduino
+board = esp32dev
+monitor_speed = 115200
+monitor_filters = esp32_exception_decoder
+lib_deps = 
+    https://github.com/hoeken/PsychicHttp
+    bblanchon/ArduinoJson
+board_build.filesystem = littlefs
+
+[env:default]

lib/PsychicHttp/benchmark/psychichttp/src/main.cpp

@@ -0,0 +1,228 @@
+/* Wi-Fi STA Connect and Disconnect Example
+
+   This example code is in the Public Domain (or CC0 licensed, at your option.)
+
+   Unless required by applicable law or agreed to in writing, this
+   software is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
+   CONDITIONS OF ANY KIND, either express or implied.
+
+*/
+#include <Arduino.h>
+#include <WiFi.h>
+#include <PsychicHttp.h>
+#include <LittleFS.h>
+#include <ArduinoJSON.h>
+#include "_secret.h"
+
+#ifndef WIFI_SSID
+  #error "You need to enter your wifi credentials.  Copy secret.h to _secret.h and enter your credentials there."
+#endif
+
+//Enter your WIFI credentials in secret.h
+const char *ssid = WIFI_SSID;
+const char *password = WIFI_PASS;
+
+PsychicHttpServer server;
+PsychicWebSocketHandler websocketHandler;
+PsychicEventSource eventSource;
+
+const char *htmlContent = R"(
+<!DOCTYPE html>
+<html>
+<head>
+    <title>Sample HTML</title>
+</head>
+<body>
+    <h1>Hello, World!</h1>
+    <p>Lorem ipsum dolor sit amet, consectetur adipiscing elit. Proin euismod, purus a euismod
+    rhoncus, urna ipsum cursus massa, eu dictum tellus justo ac justo. Quisque ullamcorper
+    arcu nec tortor ullamcorper, vel fermentum justo fermentum. Vivamus sed velit ut elit
+    accumsan congue ut ut enim. Ut eu justo eu lacus varius gravida ut a tellus. Nulla facilisi.
+    Integer auctor consectetur ultricies. Fusce feugiat, mi sit amet bibendum viverra, orci leo
+    dapibus elit, id varius sem dui id lacus.</p>
+    <p>Lorem ipsum dolor sit amet, consectetur adipiscing elit. Proin euismod, purus a euismod
+    rhoncus, urna ipsum cursus massa, eu dictum tellus justo ac justo. Quisque ullamcorper
+    arcu nec tortor ullamcorper, vel fermentum justo fermentum. Vivamus sed velit ut elit
+    accumsan congue ut ut enim. Ut eu justo eu lacus varius gravida ut a tellus. Nulla facilisi.
+    Integer auctor consectetur ultricies. Fusce feugiat, mi sit amet bibendum viverra, orci leo
+    dapibus elit, id varius sem dui id lacus.</p>
+    <p>Lorem ipsum dolor sit amet, consectetur adipiscing elit. Proin euismod, purus a euismod
+    rhoncus, urna ipsum cursus massa, eu dictum tellus justo ac justo. Quisque ullamcorper
+    arcu nec tortor ullamcorper, vel fermentum justo fermentum. Vivamus sed velit ut elit
+    accumsan congue ut ut enim. Ut eu justo eu lacus varius gravida ut a tellus. Nulla facilisi.
+    Integer auctor consectetur ultricies. Fusce feugiat, mi sit amet bibendum viverra, orci leo
+    dapibus elit, id varius sem dui id lacus.</p>
+    <p>Lorem ipsum dolor sit amet, consectetur adipiscing elit. Proin euismod, purus a euismod
+    rhoncus, urna ipsum cursus massa, eu dictum tellus justo ac justo. Quisque ullamcorper
+    arcu nec tortor ullamcorper, vel fermentum justo fermentum. Vivamus sed velit ut elit
+    accumsan congue ut ut enim. Ut eu justo eu lacus varius gravida ut a tellus. Nulla facilisi.
+    Integer auctor consectetur ultricies. Fusce feugiat, mi sit amet bibendum viverra, orci leo
+    dapibus elit, id varius sem dui id lacus.</p>
+    <p>Lorem ipsum dolor sit amet, consectetur adipiscing elit. Proin euismod, purus a euismod
+    rhoncus, urna ipsum cursus massa, eu dictum tellus justo ac justo. Quisque ullamcorper
+    arcu nec tortor ullamcorper, vel fermentum justo fermentum. Vivamus sed velit ut elit
+    accumsan congue ut ut enim. Ut eu justo eu lacus varius gravida ut a tellus. Nulla facilisi.
+    Integer auctor consectetur ultricies. Fusce feugiat, mi sit amet bibendum viverra, orci leo
+    dapibus elit, id varius sem dui id lacus.</p>
+    <p>Lorem ipsum dolor sit amet, consectetur adipiscing elit. Proin euismod, purus a euismod
+    rhoncus, urna ipsum cursus massa, eu dictum tellus justo ac justo. Quisque ullamcorper
+    arcu nec tortor ullamcorper, vel fermentum justo fermentum. Vivamus sed velit ut elit
+    accumsan congue ut ut enim. Ut eu justo eu lacus varius gravida ut a tellus. Nulla facilisi.
+    Integer auctor consectetur ultricies. Fusce feugiat, mi sit amet bibendum viverra, orci leo
+    dapibus elit, id varius sem dui id lacus.</p>
+    <p>Lorem ipsum dolor sit amet, consectetur adipiscing elit. Proin euismod, purus a euismod
+    rhoncus, urna ipsum cursus massa, eu dictum tellus justo ac justo. Quisque ullamcorper
+    arcu nec tortor ullamcorper, vel fermentum justo fermentum. Vivamus sed velit ut elit
+    accumsan congue ut ut enim. Ut eu justo eu lacus varius gravida ut a tellus. Nulla facilisi.
+    Integer auctor consectetur ultricies. Fusce feugiat, mi sit amet bibendum viverra, orci leo
+    dapibus elit, id varius sem dui id lacus.</p>
+    <p>Lorem ipsum dolor sit amet, consectetur adipiscing elit. Proin euismod, purus a euismod
+    rhoncus, urna ipsum cursus massa, eu dictum tellus justo ac justo. Quisque ullamcorper
+    arcu nec tortor ullamcorper, vel fermentum justo fermentum. Vivamus sed velit ut elit
+    accumsan congue ut ut enim. Ut eu justo eu lacus varius gravida ut a tellus. Nulla facilisi.
+    Integer auctor consectetur ultricies. Fusce feugiat, mi sit amet bibendum viverra, orci leo
+    dapibus elit, id varius sem dui id lacus.</p>
+</body>
+</html>
+)";
+
+bool connectToWifi()
+{
+  Serial.println();
+  Serial.print("[WiFi] Connecting to ");
+  Serial.println(ssid);
+
+  WiFi.setSleep(false);
+  WiFi.useStaticBuffers(true);
+
+  WiFi.begin(ssid, password);
+
+  // Will try for about 10 seconds (20x 500ms)
+  int tryDelay = 500;
+  int numberOfTries = 20;
+
+  // Wait for the WiFi event
+  while (true)
+  {
+    switch (WiFi.status())
+    {
+      case WL_NO_SSID_AVAIL:
+        Serial.println("[WiFi] SSID not found");
+        break;
+      case WL_CONNECT_FAILED:
+        Serial.print("[WiFi] Failed - WiFi not connected! Reason: ");
+        return false;
+        break;
+      case WL_CONNECTION_LOST:
+        Serial.println("[WiFi] Connection was lost");
+        break;
+      case WL_SCAN_COMPLETED:
+        Serial.println("[WiFi] Scan is completed");
+        break;
+      case WL_DISCONNECTED:
+        Serial.println("[WiFi] WiFi is disconnected");
+        break;
+      case WL_CONNECTED:
+        Serial.println("[WiFi] WiFi is connected!");
+        Serial.print("[WiFi] IP address: ");
+        Serial.println(WiFi.localIP());
+        return true;
+        break;
+      default:
+        Serial.print("[WiFi] WiFi Status: ");
+        Serial.println(WiFi.status());
+        break;
+    }
+    delay(tryDelay);
+
+    if (numberOfTries <= 0)
+    {
+      Serial.print("[WiFi] Failed to connect to WiFi!");
+      // Use disconnect function to force stop trying to connect
+      WiFi.disconnect();
+      return false;
+    }
+    else
+    {
+      numberOfTries--;
+    }
+  }
+
+  return false;
+}
+
+void setup()
+{
+  Serial.begin(115200);
+  delay(10);
+  Serial.println("PsychicHTTP Benchmark");
+
+  if (connectToWifi())
+  {
+    if(!LittleFS.begin())
+    {
+      Serial.println("LittleFS Mount Failed. Do Platform -> Build Filesystem Image and Platform -> Upload Filesystem Image from VSCode");
+      return;
+    }
+
+    //start our server
+    server.listen(80);
+
+    //our index
+    server.on("/", HTTP_GET, [](PsychicRequest *request)
+    {
+      return request->reply(200, "text/html", htmlContent);
+    });
+
+    //serve static files from LittleFS/www on /
+    server.serveStatic("/", LittleFS, "/www/");
+
+    //a websocket echo server
+    websocketHandler.onOpen([](PsychicWebSocketClient *client) {
+      client->sendMessage("Hello!");
+    });
+    websocketHandler.onFrame([](PsychicWebSocketRequest *request, httpd_ws_frame *frame) {
+      request->reply(frame);
+      return ESP_OK;
+    });
+    server.on("/ws", &websocketHandler);
+
+    //EventSource server
+    eventSource.onOpen([](PsychicEventSourceClient *client) {
+      client->send("Hello", NULL, millis(), 1000);
+    });
+    server.on("/events", &eventSource);
+
+    //api - parameters passed in via query eg. /api/endpoint?foo=bar
+    server.on("/api", HTTP_GET, [](PsychicRequest *request)
+    {
+      //create a response object
+      StaticJsonDocument<128> output;
+      output["msg"] = "status";
+      output["status"] = "success";
+      output["millis"] = millis();
+
+      //work with some params
+      if (request->hasParam("foo"))
+      {
+        String foo = request->getParam("foo")->value();
+        output["foo"] = foo;
+      }
+
+      //serialize and return
+      String jsonBuffer;
+      serializeJson(output, jsonBuffer);
+      return request->reply(200, "application/json", jsonBuffer.c_str());
+    });
+  }
+}
+
+unsigned long last;
+void loop()
+{
+  if (millis() - last > 1000)
+  {
+    Serial.printf("Free Heap: %d\n", esp_get_free_heap_size());
+    last = millis();
+  }
+}

lib/PsychicHttp/benchmark/psychichttp/src/secret.h

@@ -0,0 +1,2 @@
+#define WIFI_SSID "Your_SSID"
+#define WIFI_PASS "Your_PASS"

lib/PsychicHttp/benchmark/psychichttp/test/README

@@ -0,0 +1,11 @@
+
+This directory is intended for PlatformIO Test Runner and project tests.
+
+Unit Testing is a software testing method by which individual units of
+source code, sets of one or more MCU program modules together with associated
+control data, usage procedures, and operating procedures, are tested to
+determine whether they are fit for use. Unit testing finds problems early
+in the development cycle.
+
+More information about PlatformIO Unit Testing:
+- https://docs.platformio.org/en/latest/advanced/unit-testing/index.html

lib/PsychicHttp/benchmark/psychichttps/.gitignore

@@ -0,0 +1,6 @@
+.pio
+.vscode/
+.vscode/.browse.c_cpp.db*
+.vscode/c_cpp_properties.json
+.vscode/launch.json
+.vscode/ipch

lib/PsychicHttp/benchmark/psychichttps/data/server.crt

@@ -0,0 +1,19 @@
+-----BEGIN CERTIFICATE-----
+MIIDKzCCAhOgAwIBAgIUBxM3WJf2bP12kAfqhmhhjZWv0ukwDQYJKoZIhvcNAQEL
+BQAwJTEjMCEGA1UEAwwaRVNQMzIgSFRUUFMgc2VydmVyIGV4YW1wbGUwHhcNMTgx
+MDE3MTEzMjU3WhcNMjgxMDE0MTEzMjU3WjAlMSMwIQYDVQQDDBpFU1AzMiBIVFRQ
+UyBzZXJ2ZXIgZXhhbXBsZTCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEB
+ALBint6nP77RCQcmKgwPtTsGK0uClxg+LwKJ3WXuye3oqnnjqJCwMEneXzGdG09T
+sA0SyNPwrEgebLCH80an3gWU4pHDdqGHfJQa2jBL290e/5L5MB+6PTs2NKcojK/k
+qcZkn58MWXhDW1NpAnJtjVniK2Ksvr/YIYSbyD+JiEs0MGxEx+kOl9d7hRHJaIzd
+GF/vO2pl295v1qXekAlkgNMtYIVAjUy9CMpqaQBCQRL+BmPSJRkXBsYk8GPnieS4
+sUsp53DsNvCCtWDT6fd9D1v+BB6nDk/FCPKhtjYOwOAZlX4wWNSZpRNr5dfrxKsb
+jAn4PCuR2akdF4G8WLUeDWECAwEAAaNTMFEwHQYDVR0OBBYEFMnmdJKOEepXrHI/
+ivM6mVqJgAX8MB8GA1UdIwQYMBaAFMnmdJKOEepXrHI/ivM6mVqJgAX8MA8GA1Ud
+EwEB/wQFMAMBAf8wDQYJKoZIhvcNAQELBQADggEBADiXIGEkSsN0SLSfCF1VNWO3
+emBurfOcDq4EGEaxRKAU0814VEmU87btIDx80+z5Dbf+GGHCPrY7odIkxGNn0DJY
+W1WcF+DOcbiWoUN6DTkAML0SMnp8aGj9ffx3x+qoggT+vGdWVVA4pgwqZT7Ybntx
+bkzcNFW0sqmCv4IN1t4w6L0A87ZwsNwVpre/j6uyBw7s8YoJHDLRFT6g7qgn0tcN
+ZufhNISvgWCVJQy/SZjNBHSpnIdCUSJAeTY2mkM4sGxY0Widk8LnjydxZUSxC3Nl
+hb6pnMh3jRq4h0+5CZielA4/a+TdrNPv/qok67ot/XJdY3qHCCd8O2b14OVq9jo=
+-----END CERTIFICATE-----

lib/PsychicHttp/benchmark/psychichttps/data/server.key

@@ -0,0 +1,28 @@
+-----BEGIN PRIVATE KEY-----
+MIIEvgIBADANBgkqhkiG9w0BAQEFAASCBKgwggSkAgEAAoIBAQCwYp7epz++0QkH
+JioMD7U7BitLgpcYPi8Cid1l7snt6Kp546iQsDBJ3l8xnRtPU7ANEsjT8KxIHmyw
+h/NGp94FlOKRw3ahh3yUGtowS9vdHv+S+TAfuj07NjSnKIyv5KnGZJ+fDFl4Q1tT
+aQJybY1Z4itirL6/2CGEm8g/iYhLNDBsRMfpDpfXe4URyWiM3Rhf7ztqZdveb9al
+3pAJZIDTLWCFQI1MvQjKamkAQkES/gZj0iUZFwbGJPBj54nkuLFLKedw7DbwgrVg
+0+n3fQ9b/gQepw5PxQjyobY2DsDgGZV+MFjUmaUTa+XX68SrG4wJ+DwrkdmpHReB
+vFi1Hg1hAgMBAAECggEAaTCnZkl/7qBjLexIryC/CBBJyaJ70W1kQ7NMYfniWwui
+f0aRxJgOdD81rjTvkINsPp+xPRQO6oOadjzdjImYEuQTqrJTEUnntbu924eh+2D9
+Mf2CAanj0mglRnscS9mmljZ0KzoGMX6Z/EhnuS40WiJTlWlH6MlQU/FDnwC6U34y
+JKy6/jGryfsx+kGU/NRvKSru6JYJWt5v7sOrymHWD62IT59h3blOiP8GMtYKeQlX
+49om9Mo1VTIFASY3lrxmexbY+6FG8YO+tfIe0tTAiGrkb9Pz6tYbaj9FjEWOv4Vc
++3VMBUVdGJjgqvE8fx+/+mHo4Rg69BUPfPSrpEg7sQKBgQDlL85G04VZgrNZgOx6
+pTlCCl/NkfNb1OYa0BELqWINoWaWQHnm6lX8YjrUjwRpBF5s7mFhguFjUjp/NW6D
+0EEg5BmO0ePJ3dLKSeOA7gMo7y7kAcD/YGToqAaGljkBI+IAWK5Su5yldrECTQKG
+YnMKyQ1MWUfCYEwHtPvFvE5aPwKBgQDFBWXekpxHIvt/B41Cl/TftAzE7/f58JjV
+MFo/JCh9TDcH6N5TMTRS1/iQrv5M6kJSSrHnq8pqDXOwfHLwxetpk9tr937VRzoL
+CuG1Ar7c1AO6ujNnAEmUVC2DppL/ck5mRPWK/kgLwZSaNcZf8sydRgphsW1ogJin
+7g0nGbFwXwKBgQCPoZY07Pr1TeP4g8OwWTu5F6dSvdU2CAbtZthH5q98u1n/cAj1
+noak1Srpa3foGMTUn9CHu+5kwHPIpUPNeAZZBpq91uxa5pnkDMp3UrLIRJ2uZyr8
+4PxcknEEh8DR5hsM/IbDcrCJQglM19ZtQeW3LKkY4BsIxjDf45ymH407IQKBgE/g
+Ul6cPfOxQRlNLH4VMVgInSyyxWx1mODFy7DRrgCuh5kTVh+QUVBM8x9lcwAn8V9/
+nQT55wR8E603pznqY/jX0xvAqZE6YVPcw4kpZcwNwL1RhEl8GliikBlRzUL3SsW3
+q30AfqEViHPE3XpE66PPo6Hb1ymJCVr77iUuC3wtAoGBAIBrOGunv1qZMfqmwAY2
+lxlzRgxgSiaev0lTNxDzZkmU/u3dgdTwJ5DDANqPwJc6b8SGYTp9rQ0mbgVHnhIB
+jcJQBQkTfq6Z0H6OoTVi7dPs3ibQJFrtkoyvYAbyk36quBmNRjVh6rc8468bhXYr
+v/t+MeGJP/0Zw8v/X2CFll96
+-----END PRIVATE KEY-----

lib/PsychicHttp/benchmark/psychichttps/include/README

@@ -0,0 +1,39 @@
+
+This directory is intended for project header files.
+
+A header file is a file containing C declarations and macro definitions
+to be shared between several project source files. You request the use of a
+header file in your project source file (C, C++, etc) located in `src` folder
+by including it, with the C preprocessing directive `#include'.
+
+```src/main.c
+
+#include "header.h"
+
+int main (void)
+{
+ ...
+}
+```
+
+Including a header file produces the same results as copying the header file
+into each source file that needs it. Such copying would be time-consuming
+and error-prone. With a header file, the related declarations appear
+in only one place. If they need to be changed, they can be changed in one
+place, and programs that include the header file will automatically use the
+new version when next recompiled. The header file eliminates the labor of
+finding and changing all the copies as well as the risk that a failure to
+find one copy will result in inconsistencies within a program.
+
+In C, the usual convention is to give header files names that end with `.h'.
+It is most portable to use only letters, digits, dashes, and underscores in
+header file names, and at most one dot.
+
+Read more about using header files in official GCC documentation:
+
+* Include Syntax
+* Include Operation
+* Once-Only Headers
+* Computed Includes
+
+https://gcc.gnu.org/onlinedocs/cpp/Header-Files.html

lib/PsychicHttp/benchmark/psychichttps/lib/README

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

lib/PsychicHttp/benchmark/psychichttps/platformio.ini

@@ -0,0 +1,22 @@
+; PlatformIO Project Configuration File
+;
+;   Build options: build flags, source filter
+;   Upload options: custom upload port, speed and extra flags
+;   Library options: dependencies, extra library storages
+;   Advanced options: extra scripting
+;
+; Please visit documentation for the other options and examples
+; https://docs.platformio.org/page/projectconf.html
+
+[env]
+platform = espressif32
+framework = arduino
+board = esp32dev
+monitor_speed = 115200
+monitor_filters = esp32_exception_decoder
+lib_deps = 
+    https://github.com/hoeken/PsychicHttp
+    bblanchon/ArduinoJson
+board_build.filesystem = littlefs
+
+[env:default]

lib/PsychicHttp/benchmark/psychichttps/src/main.cpp

@@ -0,0 +1,240 @@
+/* Wi-Fi STA Connect and Disconnect Example
+
+   This example code is in the Public Domain (or CC0 licensed, at your option.)
+
+   Unless required by applicable law or agreed to in writing, this
+   software is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
+   CONDITIONS OF ANY KIND, either express or implied.
+
+*/
+#include <Arduino.h>
+#include <WiFi.h>
+#include <PsychicHttp.h>
+#include <LittleFS.h>
+#include <ArduinoJSON.h>
+#include "_secret.h"
+#include <PsychicHttp.h>
+#include <PsychicHttpsServer.h>
+
+#ifndef WIFI_SSID
+  #error "You need to enter your wifi credentials. Rename secret.h to _secret.h and enter your credentials there."
+#endif
+
+//Enter your WIFI credentials in secret.h
+const char *ssid = WIFI_SSID;
+const char *password = WIFI_PASS;
+
+PsychicHttpsServer server;
+PsychicWebSocketHandler websocketHandler;
+
+String server_cert;
+String server_key;
+
+const char *htmlContent = R"(
+<!DOCTYPE html>
+<html>
+<head>
+    <title>Sample HTML</title>
+</head>
+<body>
+    <h1>Hello, World!</h1>
+    <p>Lorem ipsum dolor sit amet, consectetur adipiscing elit. Proin euismod, purus a euismod
+    rhoncus, urna ipsum cursus massa, eu dictum tellus justo ac justo. Quisque ullamcorper
+    arcu nec tortor ullamcorper, vel fermentum justo fermentum. Vivamus sed velit ut elit
+    accumsan congue ut ut enim. Ut eu justo eu lacus varius gravida ut a tellus. Nulla facilisi.
+    Integer auctor consectetur ultricies. Fusce feugiat, mi sit amet bibendum viverra, orci leo
+    dapibus elit, id varius sem dui id lacus.</p>
+    <p>Lorem ipsum dolor sit amet, consectetur adipiscing elit. Proin euismod, purus a euismod
+    rhoncus, urna ipsum cursus massa, eu dictum tellus justo ac justo. Quisque ullamcorper
+    arcu nec tortor ullamcorper, vel fermentum justo fermentum. Vivamus sed velit ut elit
+    accumsan congue ut ut enim. Ut eu justo eu lacus varius gravida ut a tellus. Nulla facilisi.
+    Integer auctor consectetur ultricies. Fusce feugiat, mi sit amet bibendum viverra, orci leo
+    dapibus elit, id varius sem dui id lacus.</p>
+    <p>Lorem ipsum dolor sit amet, consectetur adipiscing elit. Proin euismod, purus a euismod
+    rhoncus, urna ipsum cursus massa, eu dictum tellus justo ac justo. Quisque ullamcorper
+    arcu nec tortor ullamcorper, vel fermentum justo fermentum. Vivamus sed velit ut elit
+    accumsan congue ut ut enim. Ut eu justo eu lacus varius gravida ut a tellus. Nulla facilisi.
+    Integer auctor consectetur ultricies. Fusce feugiat, mi sit amet bibendum viverra, orci leo
+    dapibus elit, id varius sem dui id lacus.</p>
+    <p>Lorem ipsum dolor sit amet, consectetur adipiscing elit. Proin euismod, purus a euismod
+    rhoncus, urna ipsum cursus massa, eu dictum tellus justo ac justo. Quisque ullamcorper
+    arcu nec tortor ullamcorper, vel fermentum justo fermentum. Vivamus sed velit ut elit
+    accumsan congue ut ut enim. Ut eu justo eu lacus varius gravida ut a tellus. Nulla facilisi.
+    Integer auctor consectetur ultricies. Fusce feugiat, mi sit amet bibendum viverra, orci leo
+    dapibus elit, id varius sem dui id lacus.</p>
+    <p>Lorem ipsum dolor sit amet, consectetur adipiscing elit. Proin euismod, purus a euismod
+    rhoncus, urna ipsum cursus massa, eu dictum tellus justo ac justo. Quisque ullamcorper
+    arcu nec tortor ullamcorper, vel fermentum justo fermentum. Vivamus sed velit ut elit
+    accumsan congue ut ut enim. Ut eu justo eu lacus varius gravida ut a tellus. Nulla facilisi.
+    Integer auctor consectetur ultricies. Fusce feugiat, mi sit amet bibendum viverra, orci leo
+    dapibus elit, id varius sem dui id lacus.</p>
+    <p>Lorem ipsum dolor sit amet, consectetur adipiscing elit. Proin euismod, purus a euismod
+    rhoncus, urna ipsum cursus massa, eu dictum tellus justo ac justo. Quisque ullamcorper
+    arcu nec tortor ullamcorper, vel fermentum justo fermentum. Vivamus sed velit ut elit
+    accumsan congue ut ut enim. Ut eu justo eu lacus varius gravida ut a tellus. Nulla facilisi.
+    Integer auctor consectetur ultricies. Fusce feugiat, mi sit amet bibendum viverra, orci leo
+    dapibus elit, id varius sem dui id lacus.</p>
+    <p>Lorem ipsum dolor sit amet, consectetur adipiscing elit. Proin euismod, purus a euismod
+    rhoncus, urna ipsum cursus massa, eu dictum tellus justo ac justo. Quisque ullamcorper
+    arcu nec tortor ullamcorper, vel fermentum justo fermentum. Vivamus sed velit ut elit
+    accumsan congue ut ut enim. Ut eu justo eu lacus varius gravida ut a tellus. Nulla facilisi.
+    Integer auctor consectetur ultricies. Fusce feugiat, mi sit amet bibendum viverra, orci leo
+    dapibus elit, id varius sem dui id lacus.</p>
+    <p>Lorem ipsum dolor sit amet, consectetur adipiscing elit. Proin euismod, purus a euismod
+    rhoncus, urna ipsum cursus massa, eu dictum tellus justo ac justo. Quisque ullamcorper
+    arcu nec tortor ullamcorper, vel fermentum justo fermentum. Vivamus sed velit ut elit
+    accumsan congue ut ut enim. Ut eu justo eu lacus varius gravida ut a tellus. Nulla facilisi.
+    Integer auctor consectetur ultricies. Fusce feugiat, mi sit amet bibendum viverra, orci leo
+    dapibus elit, id varius sem dui id lacus.</p>
+</body>
+</html>
+)";
+
+bool connectToWifi()
+{
+  Serial.println();
+  Serial.print("[WiFi] Connecting to ");
+  Serial.println(ssid);
+
+  WiFi.setSleep(false);
+
+  WiFi.begin(ssid, password);
+
+  // Will try for about 10 seconds (20x 500ms)
+  int tryDelay = 500;
+  int numberOfTries = 20;
+
+  // Wait for the WiFi event
+  while (true)
+  {
+    switch (WiFi.status())
+    {
+      case WL_NO_SSID_AVAIL:
+        Serial.println("[WiFi] SSID not found");
+        break;
+      case WL_CONNECT_FAILED:
+        Serial.print("[WiFi] Failed - WiFi not connected! Reason: ");
+        return false;
+        break;
+      case WL_CONNECTION_LOST:
+        Serial.println("[WiFi] Connection was lost");
+        break;
+      case WL_SCAN_COMPLETED:
+        Serial.println("[WiFi] Scan is completed");
+        break;
+      case WL_DISCONNECTED:
+        Serial.println("[WiFi] WiFi is disconnected");
+        break;
+      case WL_CONNECTED:
+        Serial.println("[WiFi] WiFi is connected!");
+        Serial.print("[WiFi] IP address: ");
+        Serial.println(WiFi.localIP());
+        return true;
+        break;
+      default:
+        Serial.print("[WiFi] WiFi Status: ");
+        Serial.println(WiFi.status());
+        break;
+    }
+    delay(tryDelay);
+
+    if (numberOfTries <= 0)
+    {
+      Serial.print("[WiFi] Failed to connect to WiFi!");
+      // Use disconnect function to force stop trying to connect
+      WiFi.disconnect();
+      return false;
+    }
+    else
+    {
+      numberOfTries--;
+    }
+  }
+
+  return false;
+}
+
+void setup()
+{
+  Serial.begin(115200);
+  delay(10);
+  Serial.println("PsychicHTTP Benchmark");
+
+  if (connectToWifi())
+  {
+    if(!LittleFS.begin())
+    {
+      Serial.println("LittleFS Mount Failed. Do Platform -> Build Filesystem Image and Platform -> Upload Filesystem Image from VSCode");
+      return;
+    }
+
+    File fp = LittleFS.open("/server.crt");
+    if (fp) {
+      server_cert = fp.readString();
+    } else {
+      Serial.println("server.pem not found, SSL not available");
+      return;
+    }
+    fp.close();
+
+    File fp2 = LittleFS.open("/server.key");
+    if (fp2) {
+      server_key = fp2.readString();
+    } else {
+      Serial.println("server.key not found, SSL not available");
+      return;
+    }
+    fp2.close();
+
+    //start our server
+    server.listen(443, server_cert.c_str(), server_key.c_str());
+
+    //our index
+    server.on("/", HTTP_GET, [](PsychicRequest *request)
+    {
+      return request->reply(200, "text/html", htmlContent);
+    });
+
+    //serve static files from LittleFS/www on /
+    server.serveStatic("/", LittleFS, "/www/");
+
+    //a websocket echo server
+    websocketHandler.onFrame([](PsychicWebSocketRequest *request, httpd_ws_frame *frame) {
+      request->reply(frame);
+      return ESP_OK;
+    });
+    server.on("/ws", &websocketHandler);
+
+    //api - parameters passed in via query eg. /api/endpoint?foo=bar
+    server.on("/api", HTTP_GET, [](PsychicRequest *request)
+    {
+      //create a response object
+      StaticJsonDocument<128> output;
+      output["msg"] = "status";
+      output["status"] = "success";
+      output["millis"] = millis();
+
+      //work with some params
+      if (request->hasParam("foo"))
+      {
+        String foo = request->getParam("foo")->value();
+        output["foo"] = foo;
+      }
+
+      //serialize and return
+      String jsonBuffer;
+      serializeJson(output, jsonBuffer);
+      return request->reply(200, "application/json", jsonBuffer.c_str());
+    });
+  }
+}
+
+unsigned long last;
+void loop()
+{
+  if (millis() - last > 1000)
+  {
+    Serial.printf("Free Heap: %d\n", esp_get_free_heap_size());
+    last = millis();
+  }
+}

lib/PsychicHttp/benchmark/psychichttps/src/secret.h

@@ -0,0 +1,2 @@
+#define WIFI_SSID "Your_SSID"
+#define WIFI_PASS "Your_PASS"

lib/PsychicHttp/benchmark/psychichttps/test/README

@@ -0,0 +1,11 @@
+
+This directory is intended for PlatformIO Test Runner and project tests.
+
+Unit Testing is a software testing method by which individual units of
+source code, sets of one or more MCU program modules together with associated
+control data, usage procedures, and operating procedures, are tested to
+determine whether they are fit for use. Unit testing finds problems early
+in the development cycle.
+
+More information about PlatformIO Unit Testing:
+- https://docs.platformio.org/en/latest/advanced/unit-testing/index.html

lib/PsychicHttp/benchmark/results/arduinomongoose-websocket-loadtest.log

@@ -0,0 +1,246 @@
+
+
+CLIENTS: *** 1 ***
+
+
+Target URL:          ws://192.168.2.131/ws
+Max time (s):        60
+Concurrent clients:  1
+Agent:               none
+
+Completed requests:  3750
+Total errors:        0
+Total time:          60.001 s
+Mean latency:        15.5 ms
+Effective rps:       62
+
+Percentage of requests served within a certain time
+  50%      12 ms
+  90%      18 ms
+  95%      36 ms
+  99%      80 ms
+ 100%      223 ms (longest request)
+
+
+CLIENTS: *** 2 ***
+
+
+Target URL:          ws://192.168.2.131/ws
+Max time (s):        60
+Concurrent clients:  2
+Agent:               none
+
+Completed requests:  5795
+Total errors:        0
+Total time:          60.004 s
+Mean latency:        20.2 ms
+Effective rps:       97
+
+Percentage of requests served within a certain time
+  50%      16 ms
+  90%      27 ms
+  95%      64 ms
+  99%      86 ms
+ 100%      108 ms (longest request)
+
+
+CLIENTS: *** 3 ***
+
+
+Target URL:          ws://192.168.2.131/ws
+Max time (s):        60
+Concurrent clients:  3
+Agent:               none
+
+Completed requests:  7445
+Total errors:        0
+Total time:          60.003 s
+Mean latency:        23.6 ms
+Effective rps:       124
+
+Percentage of requests served within a certain time
+  50%      19 ms
+  90%      32 ms
+  95%      70 ms
+  99%      92 ms
+ 100%      121 ms (longest request)
+
+
+CLIENTS: *** 4 ***
+
+
+Target URL:          ws://192.168.2.131/ws
+Max time (s):        60
+Concurrent clients:  4
+Agent:               none
+
+Completed requests:  8751
+Total errors:        0
+Total time:          60.005 s
+Mean latency:        26.9 ms
+Effective rps:       146
+
+Percentage of requests served within a certain time
+  50%      22 ms
+  90%      38 ms
+  95%      73 ms
+  99%      95 ms
+ 100%      115 ms (longest request)
+
+
+CLIENTS: *** 5 ***
+
+
+Target URL:          ws://192.168.2.131/ws
+Max time (s):        60
+Concurrent clients:  5
+Agent:               none
+
+Completed requests:  9953
+Total errors:        0
+Total time:          60.004 s
+Mean latency:        29.6 ms
+Effective rps:       166
+
+Percentage of requests served within a certain time
+  50%      25 ms
+  90%      42 ms
+  95%      74 ms
+  99%      93 ms
+ 100%      116 ms (longest request)
+
+
+CLIENTS: *** 6 ***
+
+
+Target URL:          ws://192.168.2.131/ws
+Max time (s):        60
+Concurrent clients:  6
+Agent:               none
+
+Completed requests:  10871
+Total errors:        0
+Total time:          60.005 s
+Mean latency:        32.6 ms
+Effective rps:       181
+
+Percentage of requests served within a certain time
+  50%      27 ms
+  90%      50 ms
+  95%      82 ms
+  99%      100 ms
+ 100%      116 ms (longest request)
+
+
+CLIENTS: *** 7 ***
+
+
+Target URL:          ws://192.168.2.131/ws
+Max time (s):        60
+Concurrent clients:  7
+Agent:               none
+
+Completed requests:  11777
+Total errors:        0
+Total time:          60.003 s
+Mean latency:        35.1 ms
+Effective rps:       196
+
+Percentage of requests served within a certain time
+  50%      30 ms
+  90%      66 ms
+  95%      83 ms
+  99%      101 ms
+ 100%      137 ms (longest request)
+
+
+CLIENTS: *** 8 ***
+
+
+Target URL:          ws://192.168.2.131/ws
+Max time (s):        60
+Concurrent clients:  8
+Running on cores:    2
+Agent:               none
+
+Completed requests:  11639
+Total errors:        0
+Total time:          60.004 s
+Mean latency:        35.4 ms
+Effective rps:       194
+
+Percentage of requests served within a certain time
+  50%      30 ms
+  90%      67 ms
+  95%      86 ms
+  99%      106 ms
+ 100%      135 ms (longest request)
+
+
+CLIENTS: *** 10 ***
+
+
+Target URL:          ws://192.168.2.131/ws
+Max time (s):        60
+Concurrent clients:  10
+Running on cores:    2
+Agent:               none
+
+Completed requests:  11619
+Total errors:        0
+Total time:          60.004 s
+Mean latency:        35.6 ms
+Effective rps:       194
+
+Percentage of requests served within a certain time
+  50%      30 ms
+  90%      71 ms
+  95%      87 ms
+  99%      105 ms
+ 100%      125 ms (longest request)
+
+
+CLIENTS: *** 16 ***
+
+
+Target URL:          ws://192.168.2.131/ws
+Max time (s):        60
+Concurrent clients:  16
+Running on cores:    2
+Agent:               none
+
+Completed requests:  15314
+Total errors:        0
+Total time:          60.005 s
+Mean latency:        54.2 ms
+Effective rps:       255
+
+Percentage of requests served within a certain time
+  50%      46 ms
+  90%      91 ms
+  95%      105 ms
+  99%      127 ms
+ 100%      826 ms (longest request)
+
+
+CLIENTS: *** 20 ***
+
+
+Target URL:          ws://192.168.2.131/ws
+Max time (s):        60
+Concurrent clients:  20
+Running on cores:    2
+Agent:               none
+
+Completed requests:  15370
+Total errors:        0
+Total time:          60.005 s
+Mean latency:        57.7 ms
+Effective rps:       256
+
+Percentage of requests served within a certain time
+  50%      48 ms
+  90%      96 ms
+  95%      110 ms
+  99%      132 ms
+ 100%      851 ms (longest request)

lib/PsychicHttp/benchmark/results/espasync-websocket-loadtest.log

@@ -0,0 +1,252 @@
+
+
+CLIENTS: *** 1 ***
+
+
+Target URL:          ws://192.168.2.131/ws
+Max time (s):        60
+Concurrent clients:  1
+Agent:               none
+
+Completed requests:  4231
+Total errors:        0
+Total time:          60.002 s
+Mean latency:        13.6 ms
+Effective rps:       71
+
+Percentage of requests served within a certain time
+  50%      10 ms
+  90%      16 ms
+  95%      24 ms
+  99%      81 ms
+ 100%      280 ms (longest request)
+
+
+CLIENTS: *** 2 ***
+
+
+Target URL:          ws://192.168.2.131/ws
+Max time (s):        60
+Concurrent clients:  2
+Agent:               none
+
+Completed requests:  5914
+Total errors:        0
+Total time:          60.001 s
+Mean latency:        19.7 ms
+Effective rps:       99
+
+Percentage of requests served within a certain time
+  50%      15 ms
+  90%      26 ms
+  95%      67 ms
+  99%      86 ms
+ 100%      109 ms (longest request)
+
+
+CLIENTS: *** 3 ***
+
+
+Target URL:          ws://192.168.2.131/ws
+Max time (s):        60
+Concurrent clients:  3
+Agent:               none
+
+Completed requests:  8204
+Total errors:        0
+Total time:          60.003 s
+Mean latency:        21.4 ms
+Effective rps:       137
+
+Percentage of requests served within a certain time
+  50%      17 ms
+  90%      29 ms
+  95%      68 ms
+  99%      87 ms
+ 100%      104 ms (longest request)
+
+
+CLIENTS: *** 4 ***
+
+
+Target URL:          ws://192.168.2.131/ws
+Max time (s):        60
+Concurrent clients:  4
+Agent:               none
+
+Completed requests:  9634
+Total errors:        0
+Total time:          60.004 s
+Mean latency:        24.4 ms
+Effective rps:       161
+
+Percentage of requests served within a certain time
+  50%      19 ms
+  90%      33 ms
+  95%      73 ms
+  99%      91 ms
+ 100%      145 ms (longest request)
+
+
+CLIENTS: *** 5 ***
+
+
+Target URL:          ws://192.168.2.131/ws
+Max time (s):        60
+Concurrent clients:  5
+Agent:               none
+
+Completed requests:  10759
+Total errors:        0
+Total time:          60.003 s
+Mean latency:        27.3 ms
+Effective rps:       179
+
+Percentage of requests served within a certain time
+  50%      22 ms
+  90%      39 ms
+  95%      76 ms
+  99%      95 ms
+ 100%      117 ms (longest request)
+
+
+CLIENTS: *** 6 ***
+
+
+Target URL:          ws://192.168.2.131/ws
+Max time (s):        60
+Concurrent clients:  6
+Agent:               none
+
+Completed requests:  11302
+Total errors:        0
+Total time:          60.004 s
+Mean latency:        31.3 ms
+Effective rps:       188
+
+Percentage of requests served within a certain time
+  50%      26 ms
+  90%      58 ms
+  95%      81 ms
+  99%      100 ms
+ 100%      122 ms (longest request)
+
+
+CLIENTS: *** 7 ***
+
+
+Target URL:          ws://192.168.2.131/ws
+Max time (s):        60
+Concurrent clients:  7
+Agent:               none
+
+Completed requests:  12713
+Total errors:        0
+Total time:          60.003 s
+Mean latency:        32.5 ms
+Effective rps:       212
+
+Percentage of requests served within a certain time
+  50%      27 ms
+  90%      52 ms
+  95%      81 ms
+  99%      99 ms
+ 100%      125 ms (longest request)
+
+
+CLIENTS: *** 8 ***
+
+
+Target URL:          ws://192.168.2.131/ws
+Max time (s):        60
+Concurrent clients:  8
+Running on cores:    2
+Agent:               none
+
+Completed requests:  13157
+Total errors:        0
+Total time:          60.003 s
+Mean latency:        35.9 ms
+Effective rps:       219
+
+Percentage of requests served within a certain time
+  50%      30 ms
+  90%      71 ms
+  95%      88 ms
+  99%      107 ms
+ 100%      132 ms (longest request)
+
+
+CLIENTS: *** 10 ***
+
+
+Target URL:          ws://192.168.2.131/ws
+Max time (s):        60
+Concurrent clients:  10
+Running on cores:    2
+Agent:               none
+
+Completed requests:  13417
+Total errors:        2
+Total time:          60.001 s
+Mean latency:        34.4 ms
+Effective rps:       224
+
+Percentage of requests served within a certain time
+  50%      30 ms
+  90%      53 ms
+  95%      81 ms
+  99%      101 ms
+ 100%      124 ms (longest request)
+
+   -1:   2 errors
+
+
+CLIENTS: *** 16 ***
+
+
+Target URL:          ws://192.168.2.131/ws
+Max time (s):        60
+Concurrent clients:  16
+Running on cores:    2
+Agent:               none
+
+Completed requests:  12804
+Total errors:        7
+Total time:          60.001 s
+Mean latency:        36.4 ms
+Effective rps:       213
+
+Percentage of requests served within a certain time
+  50%      30 ms
+  90%      70 ms
+  95%      86 ms
+  99%      106 ms
+ 100%      135 ms (longest request)
+
+   -1:   7 errors
+
+
+CLIENTS: *** 20 ***
+
+
+Target URL:          ws://192.168.2.131/ws
+Max time (s):        60
+Concurrent clients:  20
+Running on cores:    2
+Agent:               none
+
+Completed requests:  8421
+Total errors:        13
+Total time:          60.003 s
+Mean latency:        37.2 ms
+Effective rps:       140
+
+Percentage of requests served within a certain time
+  50%      20 ms
+  90%      50 ms
+  95%      77 ms
+  99%      105 ms
+ 100%      9227 ms (longest request)
+
+   -1:   13 errors

lib/PsychicHttp/benchmark/results/psychic-ssl-websocket-loadtest.log

@@ -0,0 +1,246 @@
+
+
+CLIENTS: *** 1 ***
+
+
+Target URL:          wss://192.168.2.131/ws
+Max time (s):        60
+Concurrent clients:  1
+Agent:               none
+
+Completed requests:  2039
+Total errors:        0
+Total time:          60.002 s
+Mean latency:        27.8 ms
+Effective rps:       34
+
+Percentage of requests served within a certain time
+  50%      24 ms
+  90%      34 ms
+  95%      62 ms
+  99%      97 ms
+ 100%      109 ms (longest request)
+
+
+CLIENTS: *** 2 ***
+
+
+Target URL:          wss://192.168.2.131/ws
+Max time (s):        60
+Concurrent clients:  2
+Agent:               none
+
+Completed requests:  2969
+Total errors:        0
+Total time:          60.003 s
+Mean latency:        37.7 ms
+Effective rps:       49
+
+Percentage of requests served within a certain time
+  50%      32 ms
+  90%      52 ms
+  95%      92 ms
+  99%      110 ms
+ 100%      126 ms (longest request)
+
+
+CLIENTS: *** 3 ***
+
+
+Target URL:          wss://192.168.2.131/ws
+Max time (s):        60
+Concurrent clients:  3
+Agent:               none
+
+Completed requests:  2883
+Total errors:        0
+Total time:          60.003 s
+Mean latency:        38.2 ms
+Effective rps:       48
+
+Percentage of requests served within a certain time
+  50%      32 ms
+  90%      52 ms
+  95%      86 ms
+  99%      109 ms
+ 100%      1711 ms (longest request)
+
+
+CLIENTS: *** 4 ***
+
+
+Target URL:          wss://192.168.2.131/ws
+Max time (s):        60
+Concurrent clients:  4
+Agent:               none
+
+Completed requests:  2858
+Total errors:        0
+Total time:          60.003 s
+Mean latency:        37.9 ms
+Effective rps:       48
+
+Percentage of requests served within a certain time
+  50%      32 ms
+  90%      49 ms
+  95%      76 ms
+  99%      104 ms
+ 100%      1740 ms (longest request)
+
+
+CLIENTS: *** 5 ***
+
+
+Target URL:          wss://192.168.2.131/ws
+Max time (s):        60
+Concurrent clients:  5
+Agent:               none
+
+Completed requests:  2772
+Total errors:        0
+Total time:          60.003 s
+Mean latency:        38.6 ms
+Effective rps:       46
+
+Percentage of requests served within a certain time
+  50%      32 ms
+  90%      49 ms
+  95%      79 ms
+  99%      106 ms
+ 100%      1634 ms (longest request)
+
+
+CLIENTS: *** 6 ***
+
+
+Target URL:          wss://192.168.2.131/ws
+Max time (s):        60
+Concurrent clients:  6
+Agent:               none
+
+Completed requests:  2722
+Total errors:        0
+Total time:          60.003 s
+Mean latency:        38.7 ms
+Effective rps:       45
+
+Percentage of requests served within a certain time
+  50%      32 ms
+  90%      49 ms
+  95%      72 ms
+  99%      102 ms
+ 100%      1694 ms (longest request)
+
+
+CLIENTS: *** 7 ***
+
+
+Target URL:          wss://192.168.2.131/ws
+Max time (s):        60
+Concurrent clients:  7
+Agent:               none
+
+Completed requests:  2552
+Total errors:        0
+Total time:          60.003 s
+Mean latency:        40.7 ms
+Effective rps:       43
+
+Percentage of requests served within a certain time
+  50%      32 ms
+  90%      52 ms
+  95%      86 ms
+  99%      112 ms
+ 100%      1816 ms (longest request)
+
+
+CLIENTS: *** 8 ***
+
+
+Target URL:          wss://192.168.2.131/ws
+Max time (s):        60
+Concurrent clients:  8
+Running on cores:    2
+Agent:               none
+
+Completed requests:  2507
+Total errors:        0
+Total time:          60.005 s
+Mean latency:        40.8 ms
+Effective rps:       42
+
+Percentage of requests served within a certain time
+  50%      32 ms
+  90%      50 ms
+  95%      80 ms
+  99%      112 ms
+ 100%      1646 ms (longest request)
+
+
+CLIENTS: *** 10 ***
+
+
+Target URL:          wss://192.168.2.131/ws
+Max time (s):        60
+Concurrent clients:  10
+Running on cores:    2
+Agent:               none
+
+Completed requests:  2265
+Total errors:        0
+Total time:          60.008 s
+Mean latency:        43.7 ms
+Effective rps:       38
+
+Percentage of requests served within a certain time
+  50%      33 ms
+  90%      52 ms
+  95%      79 ms
+  99%      114 ms
+ 100%      1675 ms (longest request)
+
+
+CLIENTS: *** 16 ***
+
+
+Target URL:          wss://192.168.2.131/ws
+Max time (s):        60
+Concurrent clients:  16
+Running on cores:    2
+Agent:               none
+
+Completed requests:  1795
+Total errors:        0
+Total time:          60.003 s
+Mean latency:        49.7 ms
+Effective rps:       30
+
+Percentage of requests served within a certain time
+  50%      33 ms
+  90%      51 ms
+  95%      77 ms
+  99%      112 ms
+ 100%      1741 ms (longest request)
+
+
+CLIENTS: *** 20 ***
+
+
+Target URL:          wss://192.168.2.131/ws
+Max time (s):        60
+Concurrent clients:  20
+Running on cores:    2
+Agent:               none
+
+Completed requests:  1603
+Total errors:        0
+Total time:          60.004 s
+Mean latency:        54.1 ms
+Effective rps:       27
+
+Percentage of requests served within a certain time
+  50%      33 ms
+  90%      60 ms
+  95%      94 ms
+  99%      133 ms
+ 100%      1729 ms (longest request)

lib/PsychicHttp/benchmark/results/psychic-v1.1-websocket-loadtest.log

@@ -0,0 +1,246 @@
+
+
+CLIENTS: *** 1 ***
+
+
+Target URL:          ws://192.168.2.131/ws
+Max time (s):        60
+Concurrent clients:  1
+Agent:               none
+
+Completed requests:  1972
+Total errors:        0
+Total time:          60.003 s
+Mean latency:        29.8 ms
+Effective rps:       33
+
+Percentage of requests served within a certain time
+  50%      25 ms
+  90%      40 ms
+  95%      66 ms
+  99%      96 ms
+ 100%      147 ms (longest request)
+
+
+CLIENTS: *** 2 ***
+
+
+Target URL:          ws://192.168.2.131/ws
+Max time (s):        60
+Concurrent clients:  2
+Agent:               none
+
+Completed requests:  3144
+Total errors:        0
+Total time:          60.003 s
+Mean latency:        37.6 ms
+Effective rps:       52
+
+Percentage of requests served within a certain time
+  50%      32 ms
+  90%      58 ms
+  95%      82 ms
+  99%      114 ms
+ 100%      160 ms (longest request)
+
+
+CLIENTS: *** 3 ***
+
+
+Target URL:          ws://192.168.2.131/ws
+Max time (s):        60
+Concurrent clients:  3
+Agent:               none
+
+Completed requests:  4113
+Total errors:        0
+Total time:          60.005 s
+Mean latency:        43.2 ms
+Effective rps:       69
+
+Percentage of requests served within a certain time
+  50%      38 ms
+  90%      63 ms
+  95%      88 ms
+  99%      119 ms
+ 100%      339 ms (longest request)
+
+
+CLIENTS: *** 4 ***
+
+
+Target URL:          ws://192.168.2.131/ws
+Max time (s):        60
+Concurrent clients:  4
+Agent:               none
+
+Completed requests:  4902
+Total errors:        0
+Total time:          60.004 s
+Mean latency:        48.3 ms
+Effective rps:       82
+
+Percentage of requests served within a certain time
+  50%      42 ms
+  90%      74 ms
+  95%      97 ms
+  99%      125 ms
+ 100%      217 ms (longest request)
+
+
+CLIENTS: *** 5 ***
+
+
+Target URL:          ws://192.168.2.131/ws
+Max time (s):        60
+Concurrent clients:  5
+Agent:               none
+
+Completed requests:  5522
+Total errors:        0
+Total time:          60.003 s
+Mean latency:        53.7 ms
+Effective rps:       92
+
+Percentage of requests served within a certain time
+  50%      48 ms
+  90%      81 ms
+  95%      102 ms
+  99%      122 ms
+ 100%      324 ms (longest request)
+
+
+CLIENTS: *** 6 ***
+
+
+Target URL:          ws://192.168.2.131/ws
+Max time (s):        60
+Concurrent clients:  6
+Agent:               none
+
+Completed requests:  5808
+Total errors:        0
+Total time:          60.004 s
+Mean latency:        61.4 ms
+Effective rps:       97
+
+Percentage of requests served within a certain time
+  50%      54 ms
+  90%      94 ms
+  95%      117 ms
+  99%      142 ms
+ 100%      348 ms (longest request)
+
+
+CLIENTS: *** 7 ***
+
+
+Target URL:          ws://192.168.2.131/ws
+Max time (s):        60
+Concurrent clients:  7
+Agent:               none
+
+Completed requests:  6478
+Total errors:        0
+Total time:          60.006 s
+Mean latency:        64.1 ms
+Effective rps:       108
+
+Percentage of requests served within a certain time
+  50%      59 ms
+  90%      94 ms
+  95%      110 ms
+  99%      137 ms
+ 100%      195 ms (longest request)
+
+
+CLIENTS: *** 8 ***
+
+
+Target URL:          ws://192.168.2.131/ws
+Max time (s):        60
+Concurrent clients:  8
+Running on cores:    2
+Agent:               none
+
+Completed requests:  6124
+Total errors:        0
+Total time:          60.004 s
+Mean latency:        67.8 ms
+Effective rps:       102
+
+Percentage of requests served within a certain time
+  50%      59 ms
+  90%      107 ms
+  95%      131 ms
+  99%      173 ms
+ 100%      260 ms (longest request)
+
+
+CLIENTS: *** 10 ***
+
+
+Target URL:          ws://192.168.2.131/ws
+Max time (s):        60
+Concurrent clients:  10
+Running on cores:    2
+Agent:               none
+
+Completed requests:  5640
+Total errors:        0
+Total time:          60.004 s
+Mean latency:        73.7 ms
+Effective rps:       94
+
+Percentage of requests served within a certain time
+  50%      61 ms
+  90%      120 ms
+  95%      140 ms
+  99%      240 ms
+ 100%      780 ms (longest request)
+
+
+CLIENTS: *** 16 ***
+
+
+Target URL:          ws://192.168.2.131/ws
+Max time (s):        60
+Concurrent clients:  16
+Running on cores:    2
+Agent:               none
+
+Completed requests:  5809
+Total errors:        0
+Total time:          60.006 s
+Mean latency:        71.6 ms
+Effective rps:       97
+
+Percentage of requests served within a certain time
+  50%      64 ms
+  90%      111 ms
+  95%      130 ms
+  99%      162 ms
+ 100%      226 ms (longest request)
+
+
+CLIENTS: *** 20 ***
+
+
+Target URL:          ws://192.168.2.131/ws
+Max time (s):        60
+Concurrent clients:  20
+Running on cores:    2
+Agent:               none
+
+Completed requests:  5590
+Total errors:        0
+Total time:          60.003 s
+Mean latency:        74.4 ms
+Effective rps:       93
+
+Percentage of requests served within a certain time
+  50%      61 ms
+  90%      122 ms
+  95%      151 ms
+  99%      247 ms
+ 100%      513 ms (longest request)

lib/PsychicHttp/benchmark/results/psychic-websocket-loadtest.log

@@ -0,0 +1,246 @@
+
+
+CLIENTS: *** 1 ***
+
+
+Target URL:          ws://192.168.2.131/ws
+Max time (s):        60
+Concurrent clients:  1
+Agent:               none
+
+Completed requests:  2304
+Total errors:        0
+Total time:          60.002 s
+Mean latency:        25.5 ms
+Effective rps:       38
+
+Percentage of requests served within a certain time
+  50%      22 ms
+  90%      32 ms
+  95%      58 ms
+  99%      92 ms
+ 100%      105 ms (longest request)
+
+
+CLIENTS: *** 2 ***
+
+
+Target URL:          ws://192.168.2.131/ws
+Max time (s):        60
+Concurrent clients:  2
+Agent:               none
+
+Completed requests:  3647
+Total errors:        0
+Total time:          60.002 s
+Mean latency:        32.3 ms
+Effective rps:       61
+
+Percentage of requests served within a certain time
+  50%      28 ms
+  90%      43 ms
+  95%      67 ms
+  99%      93 ms
+ 100%      135 ms (longest request)
+
+
+CLIENTS: *** 3 ***
+
+
+Target URL:          ws://192.168.2.131/ws
+Max time (s):        60
+Concurrent clients:  3
+Agent:               none
+
+Completed requests:  4629
+Total errors:        0
+Total time:          60.004 s
+Mean latency:        38.3 ms
+Effective rps:       77
+
+Percentage of requests served within a certain time
+  50%      34 ms
+  90%      51 ms
+  95%      79 ms
+  99%      110 ms
+ 100%      152 ms (longest request)
+
+
+CLIENTS: *** 4 ***
+
+
+Target URL:          ws://192.168.2.131/ws
+Max time (s):        60
+Concurrent clients:  4
+Agent:               none
+
+Completed requests:  5290
+Total errors:        0
+Total time:          60.003 s
+Mean latency:        44.7 ms
+Effective rps:       88
+
+Percentage of requests served within a certain time
+  50%      40 ms
+  90%      67 ms
+  95%      92 ms
+  99%      115 ms
+ 100%      159 ms (longest request)
+
+
+CLIENTS: *** 5 ***
+
+
+Target URL:          ws://192.168.2.131/ws
+Max time (s):        60
+Concurrent clients:  5
+Agent:               none
+
+Completed requests:  5935
+Total errors:        0
+Total time:          60.002 s
+Mean latency:        50 ms
+Effective rps:       99
+
+Percentage of requests served within a certain time
+  50%      45 ms
+  90%      74 ms
+  95%      97 ms
+  99%      123 ms
+ 100%      172 ms (longest request)
+
+
+CLIENTS: *** 6 ***
+
+
+Target URL:          ws://192.168.2.131/ws
+Max time (s):        60
+Concurrent clients:  6
+Agent:               none
+
+Completed requests:  6533
+Total errors:        0
+Total time:          60.003 s
+Mean latency:        54.5 ms
+Effective rps:       109
+
+Percentage of requests served within a certain time
+  50%      49 ms
+  90%      78 ms
+  95%      101 ms
+  99%      129 ms
+ 100%      170 ms (longest request)
+
+
+CLIENTS: *** 7 ***
+
+
+Target URL:          ws://192.168.2.131/ws
+Max time (s):        60
+Concurrent clients:  7
+Agent:               none
+
+Completed requests:  7086
+Total errors:        0
+Total time:          60.004 s
+Mean latency:        58.6 ms
+Effective rps:       118
+
+Percentage of requests served within a certain time
+  50%      54 ms
+  90%      85 ms
+  95%      107 ms
+  99%      130 ms
+ 100%      184 ms (longest request)
+
+
+CLIENTS: *** 8 ***
+
+
+Target URL:          ws://192.168.2.131/ws
+Max time (s):        60
+Concurrent clients:  8
+Running on cores:    2
+Agent:               none
+
+Completed requests:  6994
+Total errors:        0
+Total time:          60.004 s
+Mean latency:        59.3 ms
+Effective rps:       117
+
+Percentage of requests served within a certain time
+  50%      54 ms
+  90%      88 ms
+  95%      109 ms
+  99%      134 ms
+ 100%      176 ms (longest request)
+
+
+CLIENTS: *** 10 ***
+
+
+Target URL:          ws://192.168.2.131/ws
+Max time (s):        60
+Concurrent clients:  10
+Running on cores:    2
+Agent:               none
+
+Completed requests:  7197
+Total errors:        0
+Total time:          60.004 s
+Mean latency:        57.7 ms
+Effective rps:       120
+
+Percentage of requests served within a certain time
+  50%      53 ms
+  90%      83 ms
+  95%      98 ms
+  99%      123 ms
+ 100%      176 ms (longest request)
+
+
+CLIENTS: *** 16 ***
+
+
+Target URL:          ws://192.168.2.131/ws
+Max time (s):        60
+Concurrent clients:  16
+Running on cores:    2
+Agent:               none
+
+Completed requests:  7173
+Total errors:        0
+Total time:          60.002 s
+Mean latency:        57.9 ms
+Effective rps:       120
+
+Percentage of requests served within a certain time
+  50%      53 ms
+  90%      83 ms
+  95%      100 ms
+  99%      123 ms
+ 100%      156 ms (longest request)
+
+
+CLIENTS: *** 20 ***
+
+
+Target URL:          ws://192.168.2.131/ws
+Max time (s):        60
+Concurrent clients:  20
+Running on cores:    2
+Agent:               none
+
+Completed requests:  6883
+Total errors:        0
+Total time:          60.002 s
+Mean latency:        60.4 ms
+Effective rps:       115
+
+Percentage of requests served within a certain time
+  50%      55 ms
+  90%      92 ms
+  95%      111 ms
+  99%      138 ms
+ 100%      175 ms (longest request)

lib/PsychicHttp/benchmark/websocket-client-test.js

@@ -0,0 +1,36 @@
+#!/usr/bin/env node
+
+const WebSocket = require('ws');
+
+const uri = 'ws://192.168.2.131/ws';
+
+async function websocketClient() {
+  console.log(`Starting test`);
+  for (let i = 0; i < 1000000; i++) {
+    const ws = new WebSocket(uri);
+
+    if (i % 100 == 0)
+      console.log(`Count: ${i}`);
+
+    ws.on('open', () => {
+      //console.log(`Connected`);
+    });
+
+    ws.on('message', (message) => {
+      //console.log(`Message: ${message}`);
+      ws.close();
+    });
+
+    ws.on('error', (error) => {
+      console.error(`Error: ${error.message}`);
+    });
+
+    await new Promise((resolve) => {
+      ws.on('close', () => {
+        resolve();
+      });
+    });
+  }
+}
+
+websocketClient();

lib/PsychicHttp/component.mk

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

lib/PsychicHttp/examples/arduino/.gitignore

@@ -0,0 +1,6 @@
+.pio
+.vscode/
+.vscode/.browse.c_cpp.db*
+.vscode/c_cpp_properties.json
+.vscode/launch.json
+.vscode/ipch

lib/PsychicHttp/examples/arduino/arduino.ino

@@ -0,0 +1,497 @@
+/*
+  PsychicHTTP Server Example
+
+  This example code is in the Public Domain (or CC0 licensed, at your option.)
+
+  Unless required by applicable law or agreed to in writing, this
+  software is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
+  CONDITIONS OF ANY KIND, either express or implied.
+*/
+
+/**********************************************************************************************
+* Note: this demo relies on the following libraries (Install via Library Manager)
+* ArduinoJson UrlEncode
+**********************************************************************************************/
+
+/**********************************************************************************************
+* Note: this demo relies on various files to be uploaded on the LittleFS partition
+* Follow instructions here: https://randomnerdtutorials.com/esp32-littlefs-arduino-ide/
+**********************************************************************************************/
+
+#include <Arduino.h>
+#include <WiFi.h>
+#include <LittleFS.h>
+#include <ArduinoJson.h>
+#include <ESPmDNS.h>
+#include "_secret.h"
+#include <PsychicHttp.h>
+#include <PsychicHttpsServer.h> //uncomment this to enable HTTPS / SSL
+
+#ifndef WIFI_SSID
+  #error "You need to enter your wifi credentials. Rename secret.h to _secret.h and enter your credentials there."
+#endif
+
+//Enter your WIFI credentials in secret.h
+const char *ssid = WIFI_SSID;
+const char *password = WIFI_PASS;
+
+// Set your SoftAP credentials
+const char *softap_ssid = "PsychicHttp";
+const char *softap_password = "";
+IPAddress softap_ip(10, 0, 0, 1);  
+
+//credentials for the /auth-basic and /auth-digest examples
+const char *app_user = "admin";
+const char *app_pass = "admin";
+const char *app_name = "Your App";
+
+//hostname for mdns (psychic.local)
+const char *local_hostname = "psychic";
+
+//#define PSY_ENABLE_SSL to enable ssl
+#ifdef PSY_ENABLE_SSL
+  bool app_enable_ssl = true;
+  String server_cert;
+  String server_key;
+#endif
+
+//our main server object
+#ifdef PSY_ENABLE_SSL
+  PsychicHttpsServer server;
+#else
+  PsychicHttpServer server;
+#endif
+PsychicWebSocketHandler websocketHandler;
+PsychicEventSource eventSource;
+
+bool connectToWifi()
+{
+  //dual client and AP mode
+  WiFi.mode(WIFI_AP_STA);
+
+  // Configure SoftAP
+  WiFi.softAPConfig(softap_ip, softap_ip, IPAddress(255, 255, 255, 0)); // subnet FF FF FF 00
+  WiFi.softAP(softap_ssid, softap_password);
+  IPAddress myIP = WiFi.softAPIP();
+  Serial.print("SoftAP IP Address: ");
+  Serial.println(myIP);
+
+  Serial.println();
+  Serial.print("[WiFi] Connecting to ");
+  Serial.println(ssid);
+
+  WiFi.begin(ssid, password);
+  // Auto reconnect is set true as default
+  // To set auto connect off, use the following function
+  // WiFi.setAutoReconnect(false);
+
+  // Will try for about 10 seconds (20x 500ms)
+  int tryDelay = 500;
+  int numberOfTries = 20;
+
+  // Wait for the WiFi event
+  while (true)
+  {
+    switch (WiFi.status())
+    {
+      case WL_NO_SSID_AVAIL:
+        Serial.println("[WiFi] SSID not found");
+        break;
+      case WL_CONNECT_FAILED:
+        Serial.print("[WiFi] Failed - WiFi not connected! Reason: ");
+        return false;
+        break;
+      case WL_CONNECTION_LOST:
+        Serial.println("[WiFi] Connection was lost");
+        break;
+      case WL_SCAN_COMPLETED:
+        Serial.println("[WiFi] Scan is completed");
+        break;
+      case WL_DISCONNECTED:
+        Serial.println("[WiFi] WiFi is disconnected");
+        break;
+      case WL_CONNECTED:
+        Serial.println("[WiFi] WiFi is connected!");
+        Serial.print("[WiFi] IP address: ");
+        Serial.println(WiFi.localIP());
+        return true;
+        break;
+      default:
+        Serial.print("[WiFi] WiFi Status: ");
+        Serial.println(WiFi.status());
+        break;
+    }
+    delay(tryDelay);
+
+    if (numberOfTries <= 0)
+    {
+      Serial.print("[WiFi] Failed to connect to WiFi!");
+      // Use disconnect function to force stop trying to connect
+      WiFi.disconnect();
+      return false;
+    }
+    else
+    {
+      numberOfTries--;
+    }
+  }
+
+  return false;
+}
+
+void setup()
+{
+  Serial.begin(115200);
+  delay(10);
+
+  // We start by connecting to a WiFi network
+  // To debug, please enable Core Debug Level to Verbose
+  if (connectToWifi())
+  {
+    //set up our esp32 to listen on the local_hostname.local domain
+    if (!MDNS.begin(local_hostname)) {
+      Serial.println("Error starting mDNS");
+      return;
+    }
+    MDNS.addService("http", "tcp", 80);
+
+    if(!LittleFS.begin())
+    {
+      Serial.println("LittleFS Mount Failed. Do Platform -> Build Filesystem Image and Platform -> Upload Filesystem Image from VSCode");
+      return;
+    }
+
+    //look up our keys?
+    #ifdef PSY_ENABLE_SSL
+      if (app_enable_ssl)
+      {
+        File fp = LittleFS.open("/server.crt");
+        if (fp)
+        {
+          server_cert = fp.readString();
+
+          // Serial.println("Server Cert:");
+          // Serial.println(server_cert);
+        }
+        else
+        {
+          Serial.println("server.pem not found, SSL not available");
+          app_enable_ssl = false;
+        }
+        fp.close();
+
+        File fp2 = LittleFS.open("/server.key");
+        if (fp2)
+        {
+          server_key = fp2.readString();
+
+          // Serial.println("Server Key:");
+          // Serial.println(server_key);
+        }
+        else
+        {
+          Serial.println("server.key not found, SSL not available");
+          app_enable_ssl = false;
+        }
+        fp2.close();
+      }
+    #endif
+
+    //setup server config stuff here
+    server.config.max_uri_handlers = 20; //maximum number of uri handlers (.on() calls)
+
+    #ifdef PSY_ENABLE_SSL
+      server.ssl_config.httpd.max_uri_handlers = 20; //maximum number of uri handlers (.on() calls)
+
+      //do we want secure or not?
+      if (app_enable_ssl)
+      {
+        server.listen(443, server_cert.c_str(), server_key.c_str());
+        
+        //this creates a 2nd server listening on port 80 and redirects all requests HTTPS
+        PsychicHttpServer *redirectServer = new PsychicHttpServer();
+        redirectServer->config.ctrl_port = 20424; // just a random port different from the default one
+        redirectServer->listen(80);
+        redirectServer->onNotFound([](PsychicRequest *request) {
+          String url = "https://" + request->host() + request->url();
+          return request->redirect(url.c_str());
+        });
+      }
+      else
+        server.listen(80);
+    #else
+      server.listen(80);
+    #endif
+
+    //serve static files from LittleFS/www on / only to clients on same wifi network
+    //this is where our /index.html file lives
+    server.serveStatic("/", LittleFS, "/www/")->setFilter(ON_STA_FILTER);
+
+    //serve static files from LittleFS/www-ap on / only to clients on SoftAP
+    //this is where our /index.html file lives
+    server.serveStatic("/", LittleFS, "/www-ap/")->setFilter(ON_AP_FILTER);
+
+    //serve static files from LittleFS/img on /img
+    //it's more efficient to serve everything from a single www directory, but this is also possible.
+    server.serveStatic("/img", LittleFS, "/img/");
+
+    //you can also serve single files
+    server.serveStatic("/myfile.txt", LittleFS, "/custom.txt");
+
+    //example callback everytime a connection is opened
+    server.onOpen([](PsychicClient *client) {
+      Serial.printf("[http] connection #%u connected from %s\n", client->socket(), client->localIP().toString());
+    });
+
+    //example callback everytime a connection is closed
+    server.onClose([](PsychicClient *client) {
+      Serial.printf("[http] connection #%u closed from %s\n", client->socket(), client->localIP().toString());
+    });
+
+    //api - json message passed in as post body
+    server.on("/api", HTTP_POST, [](PsychicRequest *request)
+    {
+      //load our JSON request
+      StaticJsonDocument<1024> json;
+      String body = request->body();
+      DeserializationError err = deserializeJson(json, body);
+
+      //create our response json
+      StaticJsonDocument<128> output;
+      output["msg"] = "status";
+      output["status"] = "success";
+      output["millis"] = millis();
+
+      //work with some params
+      if (json.containsKey("foo"))
+      {
+        String foo = json["foo"];
+        output["foo"] = foo;
+      }
+
+      //serialize and return
+      String jsonBuffer;
+      serializeJson(output, jsonBuffer);
+      return request->reply(200, "application/json", jsonBuffer.c_str());
+    });
+
+    //api - parameters passed in via query eg. /api/endpoint?foo=bar
+    server.on("/ip", HTTP_GET, [](PsychicRequest *request)
+    {
+      String output = "Your IP is: " + request->client()->remoteIP().toString();
+      return request->reply(output.c_str());
+    });
+
+    //api - parameters passed in via query eg. /api/endpoint?foo=bar
+    server.on("/api", HTTP_GET, [](PsychicRequest *request)
+    {
+      //create a response object
+      StaticJsonDocument<128> output;
+      output["msg"] = "status";
+      output["status"] = "success";
+      output["millis"] = millis();
+
+      //work with some params
+      if (request->hasParam("foo"))
+      {
+        String foo = request->getParam("foo")->name();
+        output["foo"] = foo;
+      }
+
+      //serialize and return
+      String jsonBuffer;
+      serializeJson(output, jsonBuffer);
+      return request->reply(200, "application/json", jsonBuffer.c_str());
+    });
+
+    //how to redirect a request
+    server.on("/redirect", HTTP_GET, [](PsychicRequest *request)
+    {
+      return request->redirect("/alien.png");
+    });
+
+    //how to do basic auth
+    server.on("/auth-basic", HTTP_GET, [](PsychicRequest *request)
+    {
+      if (!request->authenticate(app_user, app_pass))
+        return request->requestAuthentication(BASIC_AUTH, app_name, "You must log in.");
+      return request->reply("Auth Basic Success!");
+    });
+
+    //how to do digest auth
+    server.on("/auth-digest", HTTP_GET, [](PsychicRequest *request)
+    {
+      if (!request->authenticate(app_user, app_pass))
+        return request->requestAuthentication(DIGEST_AUTH, app_name, "You must log in.");
+      return request->reply("Auth Digest Success!");
+    });
+
+    //example of getting / setting cookies
+    server.on("/cookies", HTTP_GET, [](PsychicRequest *request)
+    {
+      PsychicResponse response(request);
+
+      int counter = 0;
+      if (request->hasCookie("counter"))
+      {
+        counter = std::stoi(request->getCookie("counter").c_str());
+        counter++;
+      }
+
+      char cookie[10];
+      sprintf(cookie, "%i", counter);
+
+      response.setCookie("counter", cookie);
+      response.setContent(cookie);
+      return response.send();
+    });
+
+    //example of getting POST variables
+    server.on("/post", HTTP_POST, [](PsychicRequest *request)
+    {
+      String output;
+      output += "Param 1: " + request->getParam("param1")->value() + "<br/>\n";
+      output += "Param 2: " + request->getParam("param2")->value() + "<br/>\n";
+
+      return request->reply(output.c_str());
+    });
+
+    //you can set up a custom 404 handler.
+    server.onNotFound([](PsychicRequest *request)
+    {
+      return request->reply(404, "text/html", "Custom 404 Handler");
+    });
+
+    //handle a very basic upload as post body
+    PsychicUploadHandler *uploadHandler = new PsychicUploadHandler();
+    uploadHandler->onUpload([](PsychicRequest *request, const String& filename, uint64_t index, uint8_t *data, size_t len, bool last) {
+      File file;
+      String path = "/www/" + filename;
+
+      Serial.printf("Writing %d/%d bytes to: %s\n", (int)index+(int)len, request->contentLength(), path.c_str());
+
+      if (last)
+        Serial.printf("%s is finished. Total bytes: %d\n", path.c_str(), (int)index+(int)len);
+
+      //our first call?
+      if (!index)
+        file = LittleFS.open(path, FILE_WRITE);
+      else
+        file = LittleFS.open(path, FILE_APPEND);
+      
+      if(!file) {
+        Serial.println("Failed to open file");
+        return ESP_FAIL;
+      }
+
+      if(!file.write(data, len)) {
+        Serial.println("Write failed");
+        return ESP_FAIL;
+      }
+
+      return ESP_OK;
+    });
+
+    //gets called after upload has been handled
+    uploadHandler->onRequest([](PsychicRequest *request)
+    {
+      String url = "/" + request->getFilename();
+      String output = "<a href=\"" + url + "\">" + url + "</a>";
+
+      return request->reply(output.c_str());
+    });
+
+    //wildcard basic file upload - POST to /upload/filename.ext
+    server.on("/upload/*", HTTP_POST, uploadHandler);
+
+    //a little bit more complicated multipart form
+    PsychicUploadHandler *multipartHandler = new PsychicUploadHandler();
+    multipartHandler->onUpload([](PsychicRequest *request, const String& filename, uint64_t index, uint8_t *data, size_t len, bool last) {
+      File file;
+      String path = "/www/" + filename;
+
+      //some progress over serial.
+      Serial.printf("Writing %d bytes to: %s\n", (int)len, path.c_str());
+      if (last)
+        Serial.printf("%s is finished. Total bytes: %d\n", path.c_str(), (int)index+(int)len);
+
+      //our first call?
+      if (!index)
+        file = LittleFS.open(path, FILE_WRITE);
+      else
+        file = LittleFS.open(path, FILE_APPEND);
+      
+      if(!file) {
+        Serial.println("Failed to open file");
+        return ESP_FAIL;
+      }
+
+      if(!file.write(data, len)) {
+        Serial.println("Write failed");
+        return ESP_FAIL;
+      }
+
+      return ESP_OK;
+    });
+
+    //gets called after upload has been handled
+    multipartHandler->onRequest([](PsychicRequest *request)
+    {
+      PsychicWebParameter *file = request->getParam("file_upload");
+
+      String url = "/" + file->value();
+      String output;
+
+      output += "<a href=\"" + url + "\">" + url + "</a><br/>\n";
+      output += "Bytes: " + String(file->size()) + "<br/>\n";
+      output += "Param 1: " + request->getParam("param1")->value() + "<br/>\n";
+      output += "Param 2: " + request->getParam("param2")->value() + "<br/>\n";
+      
+      return request->reply(output.c_str());
+    });
+
+    //wildcard basic file upload - POST to /upload/filename.ext
+    server.on("/multipart", HTTP_POST, multipartHandler);
+
+    //a websocket echo server
+    websocketHandler.onOpen([](PsychicWebSocketClient *client) {
+      Serial.printf("[socket] connection #%u connected from %s\n", client->socket(), client->localIP().toString());
+      client->sendMessage("Hello!");
+    });
+    websocketHandler.onFrame([](PsychicWebSocketRequest *request, httpd_ws_frame *frame) {
+        Serial.printf("[socket] #%d sent: %s\n", request->client()->socket(), (char *)frame->payload);
+        return request->reply(frame);
+    });
+    websocketHandler.onClose([](PsychicWebSocketClient *client) {
+      Serial.printf("[socket] connection #%u closed from %s\n", client->socket(), client->localIP().toString());
+    });
+    server.on("/ws", &websocketHandler);
+
+    //EventSource server
+    eventSource.onOpen([](PsychicEventSourceClient *client) {
+      Serial.printf("[eventsource] connection #%u connected from %s\n", client->socket(), client->localIP().toString());
+      client->send("Hello user!", NULL, millis(), 1000);
+    });
+    eventSource.onClose([](PsychicEventSourceClient *client) {
+      Serial.printf("[eventsource] connection #%u closed from %s\n", client->socket(), client->localIP().toString());
+    });
+    server.on("/events", &eventSource);
+  }
+}
+
+unsigned long lastUpdate = 0;
+char output[60];
+
+void loop()
+{
+  if (millis() - lastUpdate > 2000)
+  {
+    sprintf(output, "Millis: %d\n", millis());
+    websocketHandler.sendAll(output);
+
+    sprintf(output, "%d", millis());
+    eventSource.send(output, "millis", millis(), 0);
+
+    lastUpdate = millis();
+  }
+}

lib/PsychicHttp/examples/arduino/arduino_captive_portal/README.md

@@ -0,0 +1,60 @@
+**1) SUMMARY**
+
+This example implements a **captive portal** with library DNSServer, ie web page which opens automatically when user connects Wifi network (eg "PsychitHttp").
+
+Captiveportal is implemented in **ESPAsyncWebServer** [https://github.com/me-no-dev/ESPAsyncWebServer/blob/master/examples/CaptivePortal/CaptivePortal.ino](url) and in **arduino-esp32 examples** [https://github.com/espressif/arduino-esp32/blob/master/libraries/DNSServer/examples/CaptivePortal/CaptivePortal.ino](url)
+
+This feature can be implemented with Psychichttp with a **dedicated handler**, as shown in code below.
+
+Code highlights are added below for reference.
+
+**2) CODE**
+
+**Definitions**
+```
+// captiveportal
+// credits https://github.com/me-no-dev/ESPAsyncWebServer/blob/master/examples/CaptivePortal/CaptivePortal.ino
+//https://github.com/espressif/arduino-esp32/blob/master/libraries/DNSServer/examples/CaptivePortal/CaptivePortal.ino
+#include <DNSServer.h> 
+DNSServer dnsServer;            
+class CaptiveRequestHandler : public PsychicWebHandler { // handler 
+public:
+  CaptiveRequestHandler() {};
+  virtual ~CaptiveRequestHandler() {};
+  bool canHandle(PsychicRequest*request){
+    // ... if needed some tests ... return(false);
+    return true;  // activate captive portal
+  }
+  esp_err_t handleRequest(PsychicRequest *request) {   
+   //PsychicFileResponse response(request, LittleFS, "/captiveportal.html"); // uncomment : for captive portal page, if any, eg "captiveportal.html"
+   //return response.send();                                                 // uncomment : return captive portal page
+   return request->reply(200,"text/html","Welcome to captive portal !");     // simple text, comment if captive portal page
+  }
+};
+CaptiveRequestHandler *captivehandler=NULL;             // handler for captive portal
+```
+
+**setup()**
+```
+    // captive portal
+    dnsServer.start(53, "*", WiFi.softAPIP());    // DNS requests are executed over port 53 (standard)     
+    captivehandler= new CaptiveRequestHandler();  // create captive portal handler, important : after server.on since handlers are triggered on a first created/first trigerred basis
+    server.addHandler(captivehandler);            // captive portal handler (last handler)
+```
+
+**loop()**
+```
+  dnsServer.processNextRequest();       // captive portal
+```
+
+**3) RESULT**
+
+**Access Point (web page is opened automatically when connecting to PsychicHttp AP)**
+![captive portal access point](images/accesspoint.png)
+
+**Station (web page is shown whatever url for Station IP, eg 192.168.1.50/abcdefg**
+![captive portal station point](images/station.png)
+
+
+
+

lib/PsychicHttp/examples/arduino/arduino_captive_portal/arduino_captive_portal.ino

@@ -0,0 +1,144 @@
+/*
+  PsychicHTTP Server Captive Portal Example
+
+  This example code is in the Public Domain (or CC0 licensed, at your option.)
+
+  Unless required by applicable law or agreed to in writing, this
+  software is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
+  CONDITIONS OF ANY KIND, either express or implied.
+*/
+
+#include <Arduino.h>
+#include <WiFi.h>
+#include <LittleFS.h>
+#include <ESPmDNS.h>
+#include <PsychicHttp.h>
+
+char* TAG = "CAPTPORT";
+
+// captiveportal
+// credits https://github.com/me-no-dev/ESPAsyncWebServer/blob/master/examples/CaptivePortal/CaptivePortal.ino
+//https://github.com/espressif/arduino-esp32/blob/master/libraries/DNSServer/examples/CaptivePortal/CaptivePortal.ino
+#include <DNSServer.h> 
+DNSServer dnsServer;            
+class CaptiveRequestHandler : public PsychicWebHandler { // handler 
+public:
+  CaptiveRequestHandler() {};
+  virtual ~CaptiveRequestHandler() {};
+  bool canHandle(PsychicRequest*request){
+    // ... if needed some tests ... return(false);
+    return true;  // activate captive portal
+  }
+  esp_err_t handleRequest(PsychicRequest *request) {   
+   //PsychicFileResponse response(request, LittleFS, "/captiveportal.html"); // uncomment : for captive portal page, if any, eg "captiveportal.html"
+   //return response.send();                                                 // uncomment : return captive portal page
+   return request->reply(200,"text/html","Welcome to captive portal !");     // simple text, comment if captive portal page
+  }
+};
+CaptiveRequestHandler *captivehandler=NULL;             // handler for captive portal
+
+const char* ssid = "mySSID";                            // replace with your SSID (mode STATION)
+const char* password = "myPassword";                    // replace with you password (mode STATION)
+
+// Set your SoftAP credentials
+const char *softap_ssid = "PsychicHttp";
+const char *softap_password = "";
+IPAddress softap_ip(10, 0, 0, 1);
+
+//hostname for mdns (psychic.local)
+const char *local_hostname = "psychic";
+
+//our main server object
+PsychicHttpServer server;
+
+bool connectToWifi() {
+ //dual client and AP mode
+  WiFi.mode(WIFI_AP_STA);
+
+  // Configure SoftAP
+  WiFi.softAPConfig(softap_ip, softap_ip, IPAddress(255, 255, 255, 0)); // subnet FF FF FF 00
+  WiFi.softAP(softap_ssid, softap_password);
+  IPAddress myIP = WiFi.softAPIP();
+  ESP_LOGI(TAG,"SoftAP IP Address: %s", myIP.toString().c_str());
+  ESP_LOGI(TAG,"[WiFi] Connecting to %s", ssid);
+
+  WiFi.begin(ssid, password);
+  
+  // Will try for about 10 seconds (20x 500ms)
+  int tryDelay = 500;
+  int numberOfTries = 20;
+
+  // Wait for the WiFi event
+  while (true) {
+    switch (WiFi.status()) {
+      case WL_NO_SSID_AVAIL:
+        ESP_LOGE(TAG,"[WiFi] SSID not found");
+        break;
+      case WL_CONNECT_FAILED:
+        ESP_LOGI(TAG,"[WiFi] Failed - WiFi not connected! Reason: ");
+        return false;
+        break;
+      case WL_CONNECTION_LOST:
+        ESP_LOGI(TAG,"[WiFi] Connection was lost");
+        break;
+      case WL_SCAN_COMPLETED:
+        ESP_LOGI(TAG,"[WiFi] Scan is completed");
+        break;
+      case WL_DISCONNECTED:
+        ESP_LOGI(TAG,"[WiFi] WiFi is disconnected");
+        break;
+      case WL_CONNECTED:
+        ESP_LOGI(TAG,"[WiFi] WiFi is connected, IP address %s",WiFi.localIP().toString().c_str());
+        return true;
+        break;
+      default:
+        ESP_LOGI(TAG,"[WiFi] WiFi Status: %d",WiFi.status());
+        break;
+    }
+    delay(tryDelay);
+    
+    if (numberOfTries <= 0) {
+      ESP_LOGI(TAG,"[WiFi] Failed to connect to WiFi!");
+      // Use disconnect function to force stop trying to connect
+      WiFi.disconnect();
+      return false;
+    }
+    else numberOfTries--;
+  }
+
+  return false;
+} // end connectToWifi
+
+void setup() {
+  Serial.begin(115200);
+  delay(10);
+
+  // Wifi
+  if (connectToWifi()) {  // set up our esp32 to listen on the local_hostname.local domain
+    if (!MDNS.begin(local_hostname)) {
+      ESP_LOGE(TAG,"Error starting mDNS");
+      return;
+    }
+    MDNS.addService("http", "tcp", 80);
+
+    if(!LittleFS.begin()) {
+      ESP_LOGI(TAG,"ERROR : LittleFS Mount Failed.");
+      return;
+    }
+
+    //setup server config stuff here
+    server.config.max_uri_handlers = 20; //maximum number of uri handlers (.on() calls)
+    server.listen(80);
+        
+    DefaultHeaders::Instance().addHeader("Server", "PsychicHttp");
+
+    // captive portal
+    dnsServer.start(53, "*", WiFi.softAPIP());    // DNS requests are executed over port 53 (standard)     
+    captivehandler= new CaptiveRequestHandler();  // create captive portal handler, important : after server.on since handlers are triggered on a first created/first trigerred basis
+    server.addHandler(captivehandler);            // captive portal handler (last handler)
+  } // end set up our esp32 to listen on the local_hostname.local domain
+} // end setup
+
+void loop() {
+  dnsServer.processNextRequest();       // captive portal
+}

lib/PsychicHttp/examples/arduino/arduino_ota/README.md

@@ -0,0 +1,138 @@
+**OTA update example for PsychicHttp**
+
+Example of OTA (Over The Air) update implementation for PsychicHttp, using Arduino IDE.
+
+**Requirements**
+Requirements for project are :
+- OTA update for code (firmware)
+- OTA update for data (littlefs)
+- manual restart of ESP32, triggered by User (no automatic restart after code or data file upload)
+
+**Implementation**
+
+OTA update relies on handler PsychicUploadHandler.
+
+Screenshots and Code are shown below.
+
+**Credits**
+
+https://github.com/hoeken/PsychicHttp/blob/master/src/PsychicUploadHandler.cpp
+
+https://github.com/hoeken/PsychicHttp/issues/30 
+
+**Configuration**
+
+Example has been implemented with following configuration :\
+Arduino IDE 1.8.19\
+arduino-32 v2.0.15\
+PsychicHttp 1.1.1\
+ESP32S3
+
+**Example Files Structure**
+
+```
+arduino_ota
+	data
+          | update.html
+	arduino_ota.ino
+	code.bin
+	littlefs.bin
+	README
+```
+"code.bin" and "littlefs.bin" are example update files which can be used to update respectily code (firmware) or data (littlefs).
+
+"Real" update files can be generated on Arduino IDE 1.x :
+- for code, menu "Sketch -> Export bin"
+- for data, using plugin arduino-esp32fs-plugin  https://github.com/lorol/arduino-esp32fs-plugin/releases
+
+**SCREENSHOTS**
+
+**Update code (firmware)**
+![otaupdate1](images/otaupdate1.png)
+
+![otaupdate2](images/otaupdate2.png)\
+```ESP-ROM:esp32s3-20210327
+Build:Mar 27 2021
+rst:0x1 (POWERON),boot:0x2b (SPI_FAST_FLASH_BOOT)
+SPIWP:0xee
+mode:DIO, clock div:1
+load:0x3fce3808,len:0x4bc
+load:0x403c9700,len:0xbd8
+load:0x403cc700,len:0x2a0c
+entry 0x403c98d0
+[332885][I][PsychicHttpServer.cpp:236] openCallback(): [psychic] New client connected 51
+[332895][I][PsychicUploadHandler.cpp:164] _multipartUploadHandler(): [psychic] Remaining size : 867306
+[332908][I][PsychicUploadHandler.cpp:164] _multipartUploadHandler(): [psychic] Remaining size : 862016
+[332919][I][arduino_ota.ino:128] operator()(): [OTA] updateHandler->onUpload _error 0 Update.hasError() 0 last 0
+[332929][I][arduino_ota.ino:133] operator()(): [OTA] update begin, filename code.bin
+[333082][I][PsychicUploadHandler.cpp:164] _multipartUploadHandler(): [psychic] Remaining size : 856272
+[333095][I][arduino_ota.ino:128] operator()(): [OTA] updateHandler->onUpload _error 0 Update.hasError() 0 last 0
+[snip]
+[339557][I][PsychicUploadHandler.cpp:164] _multipartUploadHandler(): [psychic] Remaining size : 416
+[339566][I][arduino_ota.ino:128] operator()(): [OTA] updateHandler->onUpload _error 0 Update.hasError() 0 last 1
+[339718][I][arduino_ota.ino:165] operator()(): [OTA] Update Success: 867072 written
+[339726][I][arduino_ota.ino:184] operator()(): [OTA] Update code or data OK Update.errorString() No Error
+[339738][I][PsychicHttpServer.cpp:236] openCallback(): [psychic] New client connected 52
+[339747][I][PsychicHttpServer.cpp:262] closeCallback(): [psychic] Client disconnected 52
+
+```
+
+
+**Update data (littlefs)**
+
+![otaupdate3](images/otaupdate3.png)
+```
+[ 48216][I][PsychicHttpServer.cpp:236] openCallback(): [psychic] New client connected 51
+[ 48226][I][PsychicUploadHandler.cpp:164] _multipartUploadHandler(): [psychic] Remaining size : 1573100
+[ 48239][I][PsychicUploadHandler.cpp:164] _multipartUploadHandler(): [psychic] Remaining size : 1567810
+[ 48250][I][arduino_ota.ino:128] operator()(): [OTA] updateHandler->onUpload _error 0 Update.hasError() 0 last 0
+[ 48261][I][arduino_ota.ino:133] operator()(): [OTA] update begin, filename littlefs.bin
+[ 48376][I][PsychicUploadHandler.cpp:164] _multipartUploadHandler(): [psychic] Remaining size : 1562066
+[ 48389][I][arduino_ota.ino:128] operator()(): [OTA] updateHandler->onUpload _error 0 Update.hasError() 0 last 0
+[ 48408][I][PsychicUploadHandler.cpp:164] _multipartUploadHandler(): [psychic] Remaining size : 1556322
+[ 48421][I][PsychicUploadHandler.cpp:164] _multipartUploadHandler(): [psychic] Remaining size : 1550578
+[ 48432][I][arduino_ota.ino:128] operator()(): [OTA] updateHandler->onUpload _error 0 Update.hasError() 0 last 0
+[snip]
+[ 54317][I][PsychicUploadHandler.cpp:164] _multipartUploadHandler(): [psychic] Remaining size : 16930
+[ 54327][I][arduino_ota.ino:128] operator()(): [OTA] updateHandler->onUpload _error 0 Update.hasError() 0 last 0
+[ 54340][I][PsychicUploadHandler.cpp:164] _multipartUploadHandler(): [psychic] Remaining size : 11186
+[ 54351][I][arduino_ota.ino:128] operator()(): [OTA] updateHandler->onUpload _error 0 Update.hasError() 0 last 0
+[ 54363][I][PsychicUploadHandler.cpp:164] _multipartUploadHandler(): [psychic] Remaining size : 5442
+[ 54375][I][arduino_ota.ino:128] operator()(): [OTA] updateHandler->onUpload _error 0 Update.hasError() 0 last 0
+[ 54386][I][arduino_ota.ino:128] operator()(): [OTA] updateHandler->onUpload _error 0 Update.hasError() 0 last 1
+[ 54396][I][arduino_ota.ino:165] operator()(): [OTA] Update Success: 1572864 written
+[ 54404][I][arduino_ota.ino:184] operator()(): [OTA] Update code or data OK Update.errorString() No Error
+[ 54415][I][PsychicHttpServer.cpp:236] openCallback(): [psychic] New client connected 52
+[ 54424][I][PsychicHttpServer.cpp:262] closeCallback(): [psychic] Client disconnected 52
+
+```
+
+**Restart**
+
+![otaupdate4](images/otaupdate4.png)
+
+![otaupdate5](images/otaupdate5.png)
+
+```
+[110318][I][PsychicHttpServer.cpp:236] openCallback(): [psychic] New client connected 51
+[110327][I][arduino_ota.ino:205] operator()(): [OTA] <b style='color:green'>Restarting ...</b>
+[110338][I][PsychicHttpServer.cpp:236] openCallback(): [psychic] New client connected 52
+[111317][W][WiFiGeneric.cpp:1062] _eventCallback(): Reason: 8 - ASSOC_LEAVE
+[111319][I][PsychicHttpServer.cpp:262] closeCallback(): [psychic] Client disconnected 51
+[111332][I][PsychicHttpServer.cpp:262] closeCallback(): [psychic] Client disconnected 52
+ESP-ROM:esp32s3-20210327
+Build:Mar 27 2021
+rst:0xc (RTC_SW_CPU_RST),boot:0x8 (SPI_FAST_FLASH_BOOT)
+Saved PC:0x420984ae
+SPIWP:0xee
+mode:DIO, clock div:1
+load:0x3fce3808,len:0x4bc
+load:0x403c9700,len:0xbd8
+load:0x403cc700,len:0x2a0c
+entry 0x403c98d0
+[   283][I][arduino_ota.ino:57] connectToWifi(): [OTA] [WiFi] WiFi is disconnected
+[   791][I][arduino_ota.ino:60] connectToWifi(): [OTA] [WiFi] WiFi is connected, IP address 192.168.1.50
+
+```
+
+

lib/PsychicHttp/examples/arduino/arduino_ota/arduino_ota.ino

@@ -0,0 +1,219 @@
+/*
+  Over The Air (OTA) update example for PsychicHttp web server
+
+  This example code is in the Public Domain (or CC0 licensed, at your option.)
+
+  Unless required by applicable law or agreed to in writing, this
+  software is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
+  CONDITIONS OF ANY KIND, either express or implied.
+  
+*/
+char *TAG = "OTA"; // ESP_LOG tag
+
+// PsychicHttp
+#include <Arduino.h>
+#include <WiFi.h>
+#include <LittleFS.h>
+#include <ESPmDNS.h>
+#include <PsychicHttp.h>
+PsychicHttpServer server; // main server object
+const char *local_hostname = "psychichttp"; // hostname for mdns
+
+// OTA
+#include <Update.h> 
+bool esprestart=false; // true if/when ESP should be restarted, after OTA update
+
+// Wifi
+const char *ssid = "SSID";         // your SSID
+const char *password = "PASSWORD"; // your PASSWORD
+
+bool connectToWifi() { // Wifi
+  //client in STA mode
+  WiFi.mode(WIFI_AP_STA);
+  WiFi.begin(ssid,password);
+
+  WiFi.begin(ssid, password);
+  // Will try for about 10 seconds (20x 500ms)
+  int tryDelay = 500;
+  int numberOfTries = 20;
+
+  // Wait for the WiFi event
+  while (true) {
+    switch (WiFi.status()) {
+      case WL_NO_SSID_AVAIL:
+        ESP_LOGE(TAG,"[WiFi] SSID not found");
+        break;
+      case WL_CONNECT_FAILED:
+        ESP_LOGI(TAG,"[WiFi] Failed - WiFi not connected! Reason: ");
+        return false;
+        break;
+      case WL_CONNECTION_LOST:
+        ESP_LOGI(TAG,"[WiFi] Connection was lost");
+        break;
+      case WL_SCAN_COMPLETED:
+        ESP_LOGI(TAG,"[WiFi] Scan is completed");
+        break;
+      case WL_DISCONNECTED:
+        ESP_LOGI(TAG,"[WiFi] WiFi is disconnected");
+        break;
+      case WL_CONNECTED:
+        ESP_LOGI(TAG,"[WiFi] WiFi is connected, IP address %s",WiFi.localIP().toString().c_str());
+        return true;
+        break;
+      default:
+        ESP_LOGI(TAG,"[WiFi] WiFi Status: %d",WiFi.status());
+        break;
+    }
+    delay(tryDelay);
+
+    if (numberOfTries <= 0) {
+      ESP_LOGI(TAG,"[WiFi] Failed to connect to WiFi!");
+      // Use disconnect function to force stop trying to connect
+      WiFi.disconnect();
+      return false;
+    }
+    else numberOfTries--;
+  }
+  return false;
+}
+
+
+// =======================================================================
+// setup
+// =======================================================================
+void setup()
+{ Serial.begin(115200);
+  delay(10);
+  
+  // Wifi
+  if (connectToWifi()) {  //set up our esp32 to listen on the local_hostname.local domain
+    if (!MDNS.begin(local_hostname)) {
+      ESP_LOGE(TAG,"Error starting mDNS");
+      return;
+    }
+    MDNS.addService("http", "tcp", 80);
+
+    if(!LittleFS.begin()) {
+      ESP_LOGI(TAG,"ERROR : LittleFS Mount Failed.");
+      return;
+    }
+
+    //setup server config stuff here
+    server.config.max_uri_handlers = 20;     //maximum number of uri handlers (.on() calls) 
+    server.listen(80);
+
+    DefaultHeaders::Instance().addHeader("Server", "PsychicHttp");
+
+    //server.maxRequestBodySize=2*1024*1024;   // 2Mb, change default value if needed
+    //server.maxUploadSize=64*1024*1024;       // 64Mb, change default value if needed 
+    
+    //you can set up a custom 404 handler.
+    // curl -i http://psychic.local/404
+    server.onNotFound([](PsychicRequest *request) {
+      return request->reply(404, "text/html", "Custom 404 Handler");
+    });
+
+    // OTA
+    PsychicUploadHandler *updateHandler = new PsychicUploadHandler(); // create handler for OTA update
+    updateHandler->onUpload([](PsychicRequest *request, const String& filename, uint64_t index, uint8_t *data, size_t len, bool last) { // onUpload
+      /* callback to upload code (firmware) or data (littlefs)
+       * callback is triggered for each file chunk, from first chunk (index is 0) to last chunk (last is true)
+       * callback is triggered by handler in handleRequest(), after _multipartUploadHandler() * 
+       * filename : name of file to upload, with naming convention below 
+       * "*code.bin" for code (firmware) update, eg "v1_code.bin"
+       * "*littlefs.bin" for data (little fs) update, eg "v1_littlefs.bin"     * 
+       */
+
+    int command;   //command : firmware and filesystem update type, ie code (U_FLASH 0) or data (U_SPIFFS 100)       
+    ESP_LOGI(TAG,"updateHandler->onUpload _error %d Update.hasError() %d last %d", Update.getError(), Update.hasError(), last);
+
+    // Update.abort() replaces 1st error (eg "UPDATE_ERROR_ERASE") with abort error ("UPDATE_ERROR_ABORT") so root cause is lost
+    if (!Update.hasError()) { // no error encountered so far during update, process current chunk
+      if (!index){ // index is 0, begin update (first chunk)
+        ESP_LOGI(TAG,"update begin, filename %s", filename.c_str());
+        Update.clearError();         // first chunk, clear Update error if any
+        // check if update file is code, data or sd card one
+        if (!filename.endsWith("code.bin") && !filename.endsWith("littlefs.bin")) { //  incorrect file name         
+            ESP_LOGE(TAG,"ERROR : filename %s format is incorrect", filename.c_str());
+            if (!Update.hasError()) Update.abort();
+            return(ESP_FAIL);
+        } // end incorrect file name
+        else { // file name is correct
+              // check update type : code or data
+              if (filename.endsWith("code.bin")) command=U_FLASH;       // update code
+              else command=U_SPIFFS;                                    // update data
+              if (!Update.begin(UPDATE_SIZE_UNKNOWN, command)) {        // start update with max available size           
+                // error, begin is KO        
+                if (!Update.hasError()) Update.abort();                 // abort
+                ESP_LOGE(TAG,"ERROR : update.begin error Update.errorString() %s",Update.errorString());                   
+                return(ESP_FAIL);
+              }
+        } // end file name is correct          
+      } // end begin update
+        
+      if ((len) && (!Update.hasError())) { // ongoing update if no error encountered
+        if (Update.write(data, len) != len) {  
+          // error, write is KO
+          if (!Update.hasError()) Update.abort();
+          ESP_LOGE(TAG,"ERROR : update.write len %d Update.errorString() %s",len, Update.errorString()) ;           
+          return(ESP_FAIL);
+        }   
+      } // end ongoing update
+        
+      if ((last) && (!Update.hasError())) { // last update if no error encountered
+        if (Update.end(true)) { // update end is OKTEST
+          ESP_LOGI(TAG, "Update Success: %u written", index+len);          
+        }
+        else { // update end is KO                  
+          if (!Update.hasError()) Update.abort(); // abort             
+          ESP_LOGE(TAG,"ERROR : update end error Update.errorString() %s", Update.errorString());            
+          return(ESP_FAIL);
+        }
+      } // last update if no error encountered
+      return(ESP_OK);
+    } // end no error encountered so far during update, process current chunk
+    else { // error encountered so far during update
+      return(ESP_FAIL);
+    }
+    });  // end onUpload
+
+    updateHandler->onRequest([](PsychicRequest *request) {  // triggered when update is completed (either OK or KO) and returns request's response (important)
+      String result; // request result
+      // code below is executed when update is finished
+      if (!Update.hasError()) { // update is OK
+        ESP_LOGI(TAG,"Update code or data OK Update.errorString() %s", Update.errorString());
+        result = "<b style='color:green'>Update done for file.</b>";
+        return request->reply(200,"text/html",result.c_str());
+        // ESP.restart();                                              // restart ESP if needed
+      } // end update is OK
+      else { // update is KO, send request with pretty print error
+        result = " Update.errorString() " + String(Update.errorString()); 
+        ESP_LOGE(TAG,"ERROR : error %s",result.c_str());    
+        return request->reply(500, "text/html", result.c_str());
+      } // end update is KO
+    });
+
+    server.on("/update", HTTP_GET, [](PsychicRequest*request){
+      PsychicFileResponse response(request, LittleFS, "/update.html");
+      return response.send();
+    });
+    
+    server.on("/update", HTTP_POST, updateHandler);
+
+    server.on("/restart", HTTP_POST, [](PsychicRequest *request) {
+      String output = "<b style='color:green'>Restarting ...</b>";
+      ESP_LOGI(TAG,"%s",output.c_str());      
+      esprestart=true;
+      return request->reply(output.c_str());      
+    });    
+ } // end onRequest
+
+} // end setup
+  
+// =======================================================================
+// loop
+// =======================================================================
+void loop() {
+  delay(2000);
+  if (esprestart) ESP.restart(); // restart ESP
+} // end loop

lib/PsychicHttp/examples/arduino/arduino_ota/data/update.html

@@ -0,0 +1,166 @@
+<html>
+	<head>
+		<title>PSYCHICHTTP</title>
+		<meta charset="utf-8">
+		<meta name="viewport" content="width=device-width, initial-scale=1">
+		
+		<style>
+			input[type=file]::file-selector-button {
+			margin-right: 20px;
+			border: none;
+			background: #3498db; /* blue */
+			padding: 10px 20px;
+			border-radius: 30px;
+			color: #fff;
+			cursor: pointer;
+			transition: background .2s ease-in-out;
+			}
+			
+			input[type=file]::file-selector-button:hover {
+			background: green ;		  
+			}
+			
+			.drop-container {
+			position: relative;
+			display: flex;
+			gap: 10px;
+			flex-direction: column;
+			justify-content: center;
+			align-items: center;
+			height: 150px;
+			padding: 20px;
+			border-radius: 10px;
+			border: 2px dashed #555;
+			color: #444;
+			cursor: pointer;
+			transition: background .2s ease-in-out, border .2s ease-in-out;
+			}
+			
+			.drop-container:hover {
+			background: #eee;
+			border-color: #111;
+			}
+			
+			.drop-container:hover .drop-title {
+			color: #222;
+			}
+			
+			.drop-title {
+			color: #444;
+			font-size: 20px;
+			font-weight: bold;
+			text-align: center;
+			transition: color .2s ease-in-out;
+			}
+			
+			.drop-container.drag-active {
+			background: #eee;
+			border-color: #111;
+			}
+			
+			.drop-container.drag-active .drop-title {
+			color: #222;
+			}
+			
+			.restart-button {
+			margin-right: 20px;
+			border: none;
+			background: #3498db; /* blue */
+			padding: 10px 20px;
+			border-radius: 30px;
+			color: #fff;
+			cursor: pointer;
+			transition: background .2s ease-in-out;
+			}
+			
+			.restart-button:hover {
+			background: green ;		  
+			}
+			
+		</style>
+		
+	</head>
+	
+	<body>	
+		
+		<div class="row">
+			<h1>PsychicHttp OTA Update</h1>
+		</div>
+		
+		<div><p style="text-align: left">This page allows to test OTA update with PsychicHttp, and file naming convention below :
+			<ul>
+				<li><b>"*code.bin"</b> for code (firmware) update, eg "v1_code.bin"</li>
+				<li><b>"*littlefs.bin"</b> for data (littlefs) update, eg "v1_littlefs.bin" </li>
+			</ul>
+		</div>	
+		
+		<div>
+			<form id="upload_form" enctype="multipart/form-data" method="post">
+				<label for="images" class="drop-container" id="dropcontainer">
+					<input type="file" class="inputfile" name="updatefile" id="updatefile" value="updatefile" accept=".bin" onchange="uploadFile()" required>					
+					<span class="drop-title">Or drop file here</span>
+					<progress id="progressBar" value="0" max="100" style="width:300px;"></progress>
+					<font color='black' id="status"></font>
+					<p id="loaded_n_total"></p>					
+				</label>			
+			</form>
+		</div>
+		
+		<div>
+			<p style="text-align: left">Update must be done for each of the files provided (code, littlefs). Once updates are made, the ESP32 can be restarted.		
+				<button class="restart-button" onclick="esprestartButton()">Restart</button>						
+			</p>
+		</div>		
+		
+		</body>
+		<script>
+			
+			function uploadFile() {
+			var urltocall = "/update";	
+			var xhr = new XMLHttpRequest();
+			xhr.upload.addEventListener("progress", progressHandler, false);
+			xhr.addEventListener("error", errorHandler, false);			
+			var fileupdate = document.getElementById('updatefile'); // get file structure in DOM
+			var file = fileupdate.files[0]; // get file element
+			//alert(file.name+" | "+file.size+" | "+file.type);
+			xhr.onreadystatechange = function() {
+				if (this.readyState == 4 && this.status == 200) {
+					document.getElementById("status").innerHTML = xhr.responseText; // success, show response on page 
+				}
+				else {
+					document.getElementById("status").innerHTML = xhr.responseText; // error, show response on page
+				}
+			};
+			var formdata = new FormData();
+			formdata.append("file", file);
+			xhr.open("POST", urltocall); // trigger upload request with file parameter
+			xhr.send(formdata);
+		}
+		
+		function progressHandler(event) {	
+			// document.getElementById("loaded_n_total").innerHTML = "Chargé " + event.loaded + " octets"; // do not display bytes loaded
+			var percent = (event.loaded / event.total) * 100;
+			document.getElementById("progressBar").value = Math.round(percent);		
+			document.getElementById("status").innerHTML = Math.round(percent) + "% uploaded...";
+			if (percent >= 100) {
+				document.getElementById("status").innerHTML = "Writing file ...";
+			}
+		}
+		
+		function errorHandler(event) {
+			document.getElementById("status").innerHTML = "<b style='color:red'>Error event catched by errorHandler !</b>";			
+		}
+		
+		function esprestartButton() {
+			/* restart ESP */
+			var urltocall = "/restart";
+			xhr=new XMLHttpRequest();
+			xhr.onreadystatechange = function() {
+				if (this.readyState == 4) document.getElementById("status").innerHTML = xhr.responseText;
+			};
+			xhr.open("POST", urltocall, false); // trigger restart request with file parameter
+			xhr.send();	
+		}
+		
+	</script>
+</html>			

lib/PsychicHttp/examples/arduino/data/custom.txt

@@ -0,0 +1 @@
+Custom text file.

lib/PsychicHttp/examples/arduino/data/server.crt

@@ -0,0 +1,19 @@
+-----BEGIN CERTIFICATE-----
+MIIDKzCCAhOgAwIBAgIUBxM3WJf2bP12kAfqhmhhjZWv0ukwDQYJKoZIhvcNAQEL
+BQAwJTEjMCEGA1UEAwwaRVNQMzIgSFRUUFMgc2VydmVyIGV4YW1wbGUwHhcNMTgx
+MDE3MTEzMjU3WhcNMjgxMDE0MTEzMjU3WjAlMSMwIQYDVQQDDBpFU1AzMiBIVFRQ
+UyBzZXJ2ZXIgZXhhbXBsZTCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEB
+ALBint6nP77RCQcmKgwPtTsGK0uClxg+LwKJ3WXuye3oqnnjqJCwMEneXzGdG09T
+sA0SyNPwrEgebLCH80an3gWU4pHDdqGHfJQa2jBL290e/5L5MB+6PTs2NKcojK/k
+qcZkn58MWXhDW1NpAnJtjVniK2Ksvr/YIYSbyD+JiEs0MGxEx+kOl9d7hRHJaIzd
+GF/vO2pl295v1qXekAlkgNMtYIVAjUy9CMpqaQBCQRL+BmPSJRkXBsYk8GPnieS4
+sUsp53DsNvCCtWDT6fd9D1v+BB6nDk/FCPKhtjYOwOAZlX4wWNSZpRNr5dfrxKsb
+jAn4PCuR2akdF4G8WLUeDWECAwEAAaNTMFEwHQYDVR0OBBYEFMnmdJKOEepXrHI/
+ivM6mVqJgAX8MB8GA1UdIwQYMBaAFMnmdJKOEepXrHI/ivM6mVqJgAX8MA8GA1Ud
+EwEB/wQFMAMBAf8wDQYJKoZIhvcNAQELBQADggEBADiXIGEkSsN0SLSfCF1VNWO3
+emBurfOcDq4EGEaxRKAU0814VEmU87btIDx80+z5Dbf+GGHCPrY7odIkxGNn0DJY
+W1WcF+DOcbiWoUN6DTkAML0SMnp8aGj9ffx3x+qoggT+vGdWVVA4pgwqZT7Ybntx
+bkzcNFW0sqmCv4IN1t4w6L0A87ZwsNwVpre/j6uyBw7s8YoJHDLRFT6g7qgn0tcN
+ZufhNISvgWCVJQy/SZjNBHSpnIdCUSJAeTY2mkM4sGxY0Widk8LnjydxZUSxC3Nl
+hb6pnMh3jRq4h0+5CZielA4/a+TdrNPv/qok67ot/XJdY3qHCCd8O2b14OVq9jo=
+-----END CERTIFICATE-----

lib/PsychicHttp/examples/arduino/data/server.key

@@ -0,0 +1,28 @@
+-----BEGIN PRIVATE KEY-----
+MIIEvgIBADANBgkqhkiG9w0BAQEFAASCBKgwggSkAgEAAoIBAQCwYp7epz++0QkH
+JioMD7U7BitLgpcYPi8Cid1l7snt6Kp546iQsDBJ3l8xnRtPU7ANEsjT8KxIHmyw
+h/NGp94FlOKRw3ahh3yUGtowS9vdHv+S+TAfuj07NjSnKIyv5KnGZJ+fDFl4Q1tT
+aQJybY1Z4itirL6/2CGEm8g/iYhLNDBsRMfpDpfXe4URyWiM3Rhf7ztqZdveb9al
+3pAJZIDTLWCFQI1MvQjKamkAQkES/gZj0iUZFwbGJPBj54nkuLFLKedw7DbwgrVg
+0+n3fQ9b/gQepw5PxQjyobY2DsDgGZV+MFjUmaUTa+XX68SrG4wJ+DwrkdmpHReB
+vFi1Hg1hAgMBAAECggEAaTCnZkl/7qBjLexIryC/CBBJyaJ70W1kQ7NMYfniWwui
+f0aRxJgOdD81rjTvkINsPp+xPRQO6oOadjzdjImYEuQTqrJTEUnntbu924eh+2D9
+Mf2CAanj0mglRnscS9mmljZ0KzoGMX6Z/EhnuS40WiJTlWlH6MlQU/FDnwC6U34y
+JKy6/jGryfsx+kGU/NRvKSru6JYJWt5v7sOrymHWD62IT59h3blOiP8GMtYKeQlX
+49om9Mo1VTIFASY3lrxmexbY+6FG8YO+tfIe0tTAiGrkb9Pz6tYbaj9FjEWOv4Vc
++3VMBUVdGJjgqvE8fx+/+mHo4Rg69BUPfPSrpEg7sQKBgQDlL85G04VZgrNZgOx6
+pTlCCl/NkfNb1OYa0BELqWINoWaWQHnm6lX8YjrUjwRpBF5s7mFhguFjUjp/NW6D
+0EEg5BmO0ePJ3dLKSeOA7gMo7y7kAcD/YGToqAaGljkBI+IAWK5Su5yldrECTQKG
+YnMKyQ1MWUfCYEwHtPvFvE5aPwKBgQDFBWXekpxHIvt/B41Cl/TftAzE7/f58JjV
+MFo/JCh9TDcH6N5TMTRS1/iQrv5M6kJSSrHnq8pqDXOwfHLwxetpk9tr937VRzoL
+CuG1Ar7c1AO6ujNnAEmUVC2DppL/ck5mRPWK/kgLwZSaNcZf8sydRgphsW1ogJin
+7g0nGbFwXwKBgQCPoZY07Pr1TeP4g8OwWTu5F6dSvdU2CAbtZthH5q98u1n/cAj1
+noak1Srpa3foGMTUn9CHu+5kwHPIpUPNeAZZBpq91uxa5pnkDMp3UrLIRJ2uZyr8
+4PxcknEEh8DR5hsM/IbDcrCJQglM19ZtQeW3LKkY4BsIxjDf45ymH407IQKBgE/g
+Ul6cPfOxQRlNLH4VMVgInSyyxWx1mODFy7DRrgCuh5kTVh+QUVBM8x9lcwAn8V9/
+nQT55wR8E603pznqY/jX0xvAqZE6YVPcw4kpZcwNwL1RhEl8GliikBlRzUL3SsW3
+q30AfqEViHPE3XpE66PPo6Hb1ymJCVr77iUuC3wtAoGBAIBrOGunv1qZMfqmwAY2
+lxlzRgxgSiaev0lTNxDzZkmU/u3dgdTwJ5DDANqPwJc6b8SGYTp9rQ0mbgVHnhIB
+jcJQBQkTfq6Z0H6OoTVi7dPs3ibQJFrtkoyvYAbyk36quBmNRjVh6rc8468bhXYr
+v/t+MeGJP/0Zw8v/X2CFll96
+-----END PRIVATE KEY-----

lib/PsychicHttp/examples/arduino/data/www-ap/index.html

@@ -0,0 +1,15 @@
+<!DOCTYPE html>
+<html lang="en">
+    <head>
+        <meta charset="UTF-8">
+        <meta name="viewport" content="width=device-width, initial-scale=1.0">
+        <title>PsychicHTTP SoftAP Demo</title>
+        <link rel="icon" href="./favicon.ico" type="image/x-icon">
+    </head>
+    <body>
+        <main>
+            <h1>SoftAP Demo</h1>
+            <p>You are connected to the ESP in SoftAP mode.</p>
+        </main>
+    </body>
+</html>

lib/PsychicHttp/examples/arduino/data/www/index.html

@@ -0,0 +1,236 @@
+<!DOCTYPE html>
+<html lang="en">
+    <head>
+        <meta charset="UTF-8">
+        <meta name="viewport" content="width=device-width, initial-scale=1.0">
+        <title>PsychicHTTP Demo</title>
+        <link rel="icon" href="./favicon.ico" type="image/x-icon">
+    </head>
+    <body>
+        <main>
+            <h1>Basic Request Examples</h1>
+            <ul>
+                <li><a href="/api?foo=bar">API Call</a></li>
+                <li><a href="/redirect">Redirection</a></li>
+                <li><a href="/auth-digest">Authentication (Digest)</a></li>
+                <li><a href="/auth-basic">Authentication (Basic)</a></li>
+                <li><a href="/cookies">Cookies Demo</a></li>
+                <li><a href="/404">404</a></li>
+            </ul>
+
+            <h1>Static Serving</h1>
+            <p>
+                <a href="/alien.png"><img width="60" src="/alien.png"></a>
+                <a href="/img/request_flow.png"><img width="60" src="/img/request_flow.png"></a>
+            </p>
+            <p><a href="/myfile.txt">Text File</a></p>
+
+            <h1>Simple POST Form</h1>
+            <form action="/post" method="post">
+                <label for="param1">Parameter 1:</label>
+                <input type="text" id="param1" name="param1" value="Parameter 1">            
+                <br>
+                <label for="param2">Parameter 2:</label>
+                <input type="text" id="param2" name="param2" value="Parameter 2">            
+                <br>
+                <input type="submit" value="Submit">
+            </form>            
+
+            <h1>Basic File Upload</h1>
+            <table border="0">
+                <tr>
+                    <td>
+                        <label for="newfile">Upload a file</label>
+                    </td>
+                    <td colspan="2">
+                        <input id="newfile" type="file" onchange="setpath()" style="width:100%;">
+                    </td>
+                </tr>
+                <tr>
+                    <td>
+                        <label for="filepath">Set path on server</label>
+                    </td>
+                    <td>
+                        <input id="filepath" type="text" style="width:100%;">
+                    </td>
+                </tr>
+                <tr>
+                    <td>
+                        <button id="upload" type="button" onclick="upload()">Upload</button>
+                    </td>
+                </tr>
+            </table>
+            <script>
+            function setpath() {
+                var default_path = document.getElementById("newfile").files[0].name;
+                document.getElementById("filepath").value = default_path;
+            }
+            function upload() {
+                var filePath = document.getElementById("filepath").value;
+                var upload_path = "/upload/" + filePath;
+                var fileInput = document.getElementById("newfile").files;
+
+                /* Max size of an individual file. Make sure this
+                * value is same as that set in file_server.c */
+                var MAX_FILE_SIZE = 2048*1024;
+                var MAX_FILE_SIZE_STR = "2MB";
+
+                if (fileInput.length == 0) {
+                    alert("No file selected!");
+                } else if (filePath.length == 0) {
+                    alert("File path on server is not set!");
+                } else if (filePath.indexOf(' ') >= 0) {
+                    alert("File path on server cannot have spaces!");
+                } else if (filePath[filePath.length-1] == '/') {
+                    alert("File name not specified after path!");
+                } else if (fileInput[0].size > 200*1024) {
+                    alert("File size must be less than 200KB!");
+                } else {
+                    document.getElementById("newfile").disabled = true;
+                    document.getElementById("filepath").disabled = true;
+                    document.getElementById("upload").disabled = true;
+
+                    var file = fileInput[0];
+                    var xhttp = new XMLHttpRequest();
+                    xhttp.onreadystatechange = function() {
+                        if (xhttp.readyState == 4) {
+                            if (xhttp.status == 200) {
+                                document.open();
+                                document.write(xhttp.responseText);
+                                document.close();
+                            } else if (xhttp.status == 0) {
+                                alert("Server closed the connection abruptly!");
+                                location.reload()
+                            } else {
+                                alert(xhttp.status + " Error!\n" + xhttp.responseText);
+                                location.reload()
+                            }
+                        }
+                    };
+                    xhttp.open("POST", upload_path, true);
+                    xhttp.send(file);
+                }
+            }
+            </script>
+
+            <h1>Multipart POST Form</h1>
+            <form action="/multipart" method="post" enctype="multipart/form-data">
+                <label for="param1">Parameter 1:</label>
+                <input type="text" id="param1" name="param1" value="Parameter 1">            
+                <br>
+
+                <label for="param2">Parameter 2:</label>
+                <input type="text" id="param2" name="param2" value="Parameter 2">            
+                <br>
+
+                <label for="file-upload">File Upload:</label>
+                <input type="file" id="file-upload" name="file_upload" accept=".txt, .html, .pdf, .png, .jpg, .gif" required>
+                <br>
+            
+                <input type="submit" value="Upload File">
+            </form>
+
+            <h1>Websocket Demo</h1>
+            <input type="text" id="message_input" placeholder="Type your message">
+            <button onclick="sendMessage()">Send Message</button>
+            <button onclick="websocketConnect()">Connect</button>
+            <div>
+                <textarea id="websocket_output" style="width: 50%; height: 250px;"></textarea>
+            </div>
+
+            <script>
+                let socket;
+                const outputText = document.getElementById('websocket_output');
+                const messageInput = document.getElementById('message_input');
+
+                function websocketConnect()
+                {
+                    // Create a WebSocket connection
+                    socket = new WebSocket('ws://' + window.location.host + '/ws');
+            
+                    // Event handler for when the WebSocket connection is open
+                    socket.addEventListener('open', (event) => {
+                        outputText.value += `[socket] connection opened!\n`;
+                        outputText.scrollTop = outputText.scrollHeight;
+                    });
+            
+                    // Event handler for when a message is received from the WebSocket server
+                    socket.addEventListener('message', (event) => {
+                        // Echo the received message into the output div
+                        let data = event.data.trim();
+                        outputText.value += `[received] ${data}\n`;
+                        outputText.scrollTop = outputText.scrollHeight;
+                    });
+            
+                    // Event handler for when an error occurs with the WebSocket connection
+                    socket.addEventListener('error', (event) => {
+                        let data = event.data.trim();
+                        outputText.value += `[error] ${event.data}\n`;
+                        outputText.scrollTop = outputText.scrollHeight;
+                    });
+            
+                    // Event handler for when the WebSocket connection is closed
+                    socket.addEventListener('close', (event) => {
+                        outputText.value += `[socket] connection opened!\n`;
+                    });
+                }
+        
+                // Function to send a message to the WebSocket server
+                function sendMessage() {
+                    if (socket.readyState == WebSocket.OPEN) {
+                        const message = messageInput.value.trim();
+                        if (message) {
+                            socket.send(message);
+                            messageInput.value = ''; // Clear the input field after sending the message
+                            outputText.value += `[sent] ${message}\n`;
+                            outputText.scrollTop = outputText.scrollHeight;
+                        }
+                    }
+                    else
+                    {
+                        outputText.value += `[error] Not Connected\n`;
+                        outputText.scrollTop = outputText.scrollHeight;
+                    }
+                }
+            </script>
+
+            <h1>EventSource Demo</h1>
+            <button onclick="eventSourceConnect()">Connect</button>
+            <div>
+                <textarea id="eventsource_output" style="width: 50%; height: 250px;"></textarea>
+            </div>
+
+            <script>
+                const dataElement = document.getElementById('eventsource_output');
+
+                function eventSourceConnect()
+                {
+                    const eventSource = new EventSource('/events');
+            
+                    eventSource.onopen = () => {
+                        dataElement.value += `[connected]\n`;
+                        dataElement.scrollTop = dataElement.scrollHeight;
+                    };
+
+                    eventSource.addEventListener('millis', (event) => {
+                        let data = event.data.trim()
+                        dataElement.value += `[millis] ${data}\n`;
+                        dataElement.scrollTop = dataElement.scrollHeight;
+                    });
+
+                    eventSource.onmessage = (event) => {
+                        let data = event.data.trim()
+                        dataElement.value += `[message] ${data}\n`;
+                        dataElement.scrollTop = dataElement.scrollHeight;
+                    };
+                
+                    eventSource.onerror = (error) => {
+                        dataElement.value += `[error] ${error}\n`;
+                        dataElement.scrollTop = dataElement.scrollHeight;
+                        eventSource.close();
+                    };
+                }
+              </script>
+        </main>
+    </body>
+</html>

lib/PsychicHttp/examples/arduino/data/www/text.txt

@@ -0,0 +1 @@
+Test File.

lib/PsychicHttp/examples/arduino/secret.h

@@ -0,0 +1,2 @@
+#define WIFI_SSID "Your_SSID"
+#define WIFI_PASS "Your_PASS"

lib/PsychicHttp/examples/esp-idf/.gitignore

@@ -0,0 +1,4 @@
+build/
+sdkconfig
+sdkconfig.old
+components/

lib/PsychicHttp/examples/esp-idf/CMakeLists.txt

@@ -0,0 +1,19 @@
+# The following lines of boilerplate have to be in your project's
+# CMakeLists in this exact order for cmake to work correctly
+cmake_minimum_required(VERSION 3.5)
+include($ENV{IDF_PATH}/tools/cmake/project.cmake)
+
+if(DEFINED ENV{HTTP_PATH})
+  set(HTTP_PATH $ENV{HTTP_PATH})
+else()
+  #these both work
+  set(HTTP_PATH "../../")
+  #set(HTTP_PATH ${CMAKE_CURRENT_LIST_DIR}/../../../)
+  
+  #this does not work for me...
+  #set(HTTP_PATH ${CMAKE_CURRENT_LIST_DIR}/../../../PsychicHttp)
+endif(DEFINED ENV{HTTP_PATH})
+
+set(EXTRA_COMPONENT_DIRS ${HTTP_PATH})
+
+project(PsychicHttp_IDF)

lib/PsychicHttp/examples/esp-idf/README.md

@@ -0,0 +1,7 @@
+# PsychicHttp - ESP IDF Example
+*  Download and install [ESP IDF 4.4.7](https://github.com/espressif/esp-idf/releases/tag/v4.4.7) (or later version)
+*  Clone the project: ```git clone --recursive git@github.com:hoeken/PsychicHttp.git```
+*  Run build command: ```cd PsychicHttp/examples/esp-idf``` and then ```idf.py build```
+*  Flash the LittleFS filesystem: ```esptool.py write_flash --flash_mode dio --flash_freq 40m --flash_size 4MB 0x317000 build/littlefs.bin```
+*  Flash the app firmware: ```idf.py flash monitor``` and visit the IP address shown in the console with a web browser.
+*  Learn more about [Arduino as ESP-IDF Component](https://docs.espressif.com/projects/arduino-esp32/en/latest/esp-idf_component.html)

lib/PsychicHttp/examples/esp-idf/data/custom.txt

@@ -0,0 +1 @@
+Custom text file.

lib/PsychicHttp/examples/esp-idf/data/server.crt

@@ -0,0 +1,19 @@
+-----BEGIN CERTIFICATE-----
+MIIDKzCCAhOgAwIBAgIUBxM3WJf2bP12kAfqhmhhjZWv0ukwDQYJKoZIhvcNAQEL
+BQAwJTEjMCEGA1UEAwwaRVNQMzIgSFRUUFMgc2VydmVyIGV4YW1wbGUwHhcNMTgx
+MDE3MTEzMjU3WhcNMjgxMDE0MTEzMjU3WjAlMSMwIQYDVQQDDBpFU1AzMiBIVFRQ
+UyBzZXJ2ZXIgZXhhbXBsZTCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEB
+ALBint6nP77RCQcmKgwPtTsGK0uClxg+LwKJ3WXuye3oqnnjqJCwMEneXzGdG09T
+sA0SyNPwrEgebLCH80an3gWU4pHDdqGHfJQa2jBL290e/5L5MB+6PTs2NKcojK/k
+qcZkn58MWXhDW1NpAnJtjVniK2Ksvr/YIYSbyD+JiEs0MGxEx+kOl9d7hRHJaIzd
+GF/vO2pl295v1qXekAlkgNMtYIVAjUy9CMpqaQBCQRL+BmPSJRkXBsYk8GPnieS4
+sUsp53DsNvCCtWDT6fd9D1v+BB6nDk/FCPKhtjYOwOAZlX4wWNSZpRNr5dfrxKsb
+jAn4PCuR2akdF4G8WLUeDWECAwEAAaNTMFEwHQYDVR0OBBYEFMnmdJKOEepXrHI/
+ivM6mVqJgAX8MB8GA1UdIwQYMBaAFMnmdJKOEepXrHI/ivM6mVqJgAX8MA8GA1Ud
+EwEB/wQFMAMBAf8wDQYJKoZIhvcNAQELBQADggEBADiXIGEkSsN0SLSfCF1VNWO3
+emBurfOcDq4EGEaxRKAU0814VEmU87btIDx80+z5Dbf+GGHCPrY7odIkxGNn0DJY
+W1WcF+DOcbiWoUN6DTkAML0SMnp8aGj9ffx3x+qoggT+vGdWVVA4pgwqZT7Ybntx
+bkzcNFW0sqmCv4IN1t4w6L0A87ZwsNwVpre/j6uyBw7s8YoJHDLRFT6g7qgn0tcN
+ZufhNISvgWCVJQy/SZjNBHSpnIdCUSJAeTY2mkM4sGxY0Widk8LnjydxZUSxC3Nl
+hb6pnMh3jRq4h0+5CZielA4/a+TdrNPv/qok67ot/XJdY3qHCCd8O2b14OVq9jo=
+-----END CERTIFICATE-----

lib/PsychicHttp/examples/esp-idf/data/server.key

@@ -0,0 +1,28 @@
+-----BEGIN PRIVATE KEY-----
+MIIEvgIBADANBgkqhkiG9w0BAQEFAASCBKgwggSkAgEAAoIBAQCwYp7epz++0QkH
+JioMD7U7BitLgpcYPi8Cid1l7snt6Kp546iQsDBJ3l8xnRtPU7ANEsjT8KxIHmyw
+h/NGp94FlOKRw3ahh3yUGtowS9vdHv+S+TAfuj07NjSnKIyv5KnGZJ+fDFl4Q1tT
+aQJybY1Z4itirL6/2CGEm8g/iYhLNDBsRMfpDpfXe4URyWiM3Rhf7ztqZdveb9al
+3pAJZIDTLWCFQI1MvQjKamkAQkES/gZj0iUZFwbGJPBj54nkuLFLKedw7DbwgrVg
+0+n3fQ9b/gQepw5PxQjyobY2DsDgGZV+MFjUmaUTa+XX68SrG4wJ+DwrkdmpHReB
+vFi1Hg1hAgMBAAECggEAaTCnZkl/7qBjLexIryC/CBBJyaJ70W1kQ7NMYfniWwui
+f0aRxJgOdD81rjTvkINsPp+xPRQO6oOadjzdjImYEuQTqrJTEUnntbu924eh+2D9
+Mf2CAanj0mglRnscS9mmljZ0KzoGMX6Z/EhnuS40WiJTlWlH6MlQU/FDnwC6U34y
+JKy6/jGryfsx+kGU/NRvKSru6JYJWt5v7sOrymHWD62IT59h3blOiP8GMtYKeQlX
+49om9Mo1VTIFASY3lrxmexbY+6FG8YO+tfIe0tTAiGrkb9Pz6tYbaj9FjEWOv4Vc
++3VMBUVdGJjgqvE8fx+/+mHo4Rg69BUPfPSrpEg7sQKBgQDlL85G04VZgrNZgOx6
+pTlCCl/NkfNb1OYa0BELqWINoWaWQHnm6lX8YjrUjwRpBF5s7mFhguFjUjp/NW6D
+0EEg5BmO0ePJ3dLKSeOA7gMo7y7kAcD/YGToqAaGljkBI+IAWK5Su5yldrECTQKG
+YnMKyQ1MWUfCYEwHtPvFvE5aPwKBgQDFBWXekpxHIvt/B41Cl/TftAzE7/f58JjV
+MFo/JCh9TDcH6N5TMTRS1/iQrv5M6kJSSrHnq8pqDXOwfHLwxetpk9tr937VRzoL
+CuG1Ar7c1AO6ujNnAEmUVC2DppL/ck5mRPWK/kgLwZSaNcZf8sydRgphsW1ogJin
+7g0nGbFwXwKBgQCPoZY07Pr1TeP4g8OwWTu5F6dSvdU2CAbtZthH5q98u1n/cAj1
+noak1Srpa3foGMTUn9CHu+5kwHPIpUPNeAZZBpq91uxa5pnkDMp3UrLIRJ2uZyr8
+4PxcknEEh8DR5hsM/IbDcrCJQglM19ZtQeW3LKkY4BsIxjDf45ymH407IQKBgE/g
+Ul6cPfOxQRlNLH4VMVgInSyyxWx1mODFy7DRrgCuh5kTVh+QUVBM8x9lcwAn8V9/
+nQT55wR8E603pznqY/jX0xvAqZE6YVPcw4kpZcwNwL1RhEl8GliikBlRzUL3SsW3
+q30AfqEViHPE3XpE66PPo6Hb1ymJCVr77iUuC3wtAoGBAIBrOGunv1qZMfqmwAY2
+lxlzRgxgSiaev0lTNxDzZkmU/u3dgdTwJ5DDANqPwJc6b8SGYTp9rQ0mbgVHnhIB
+jcJQBQkTfq6Z0H6OoTVi7dPs3ibQJFrtkoyvYAbyk36quBmNRjVh6rc8468bhXYr
+v/t+MeGJP/0Zw8v/X2CFll96
+-----END PRIVATE KEY-----

lib/PsychicHttp/examples/esp-idf/data/www-ap/index.html

@@ -0,0 +1,15 @@
+<!DOCTYPE html>
+<html lang="en">
+    <head>
+        <meta charset="UTF-8">
+        <meta name="viewport" content="width=device-width, initial-scale=1.0">
+        <title>PsychicHTTP SoftAP Demo</title>
+        <link rel="icon" href="./favicon.ico" type="image/x-icon">
+    </head>
+    <body>
+        <main>
+            <h1>SoftAP Demo</h1>
+            <p>You are connected to the ESP in SoftAP mode.</p>
+        </main>
+    </body>
+</html>

lib/PsychicHttp/examples/esp-idf/data/www/index.html

@@ -0,0 +1,236 @@
+<!DOCTYPE html>
+<html lang="en">
+    <head>
+        <meta charset="UTF-8">
+        <meta name="viewport" content="width=device-width, initial-scale=1.0">
+        <title>PsychicHTTP Demo</title>
+        <link rel="icon" href="./favicon.ico" type="image/x-icon">
+    </head>
+    <body>
+        <main>
+            <h1>Basic Request Examples</h1>
+            <ul>
+                <li><a href="/api?foo=bar">API Call</a></li>
+                <li><a href="/redirect">Redirection</a></li>
+                <li><a href="/auth-digest">Authentication (Digest)</a></li>
+                <li><a href="/auth-basic">Authentication (Basic)</a></li>
+                <li><a href="/cookies">Cookies Demo</a></li>
+                <li><a href="/404">404</a></li>
+            </ul>
+
+            <h1>Static Serving</h1>
+            <p>
+                <a href="/alien.png"><img width="60" src="/alien.png"></a>
+                <a href="/img/request_flow.png"><img width="60" src="/img/request_flow.png"></a>
+            </p>
+            <p><a href="/myfile.txt">Text File</a></p>
+
+            <h1>Simple POST Form</h1>
+            <form action="/post" method="post">
+                <label for="param1">Parameter 1:</label>
+                <input type="text" id="param1" name="param1" value="Parameter 1">            
+                <br>
+                <label for="param2">Parameter 2:</label>
+                <input type="text" id="param2" name="param2" value="Parameter 2">            
+                <br>
+                <input type="submit" value="Submit">
+            </form>            
+
+            <h1>Basic File Upload</h1>
+            <table border="0">
+                <tr>
+                    <td>
+                        <label for="newfile">Upload a file</label>
+                    </td>
+                    <td colspan="2">
+                        <input id="newfile" type="file" onchange="setpath()" style="width:100%;">
+                    </td>
+                </tr>
+                <tr>
+                    <td>
+                        <label for="filepath">Set path on server</label>
+                    </td>
+                    <td>
+                        <input id="filepath" type="text" style="width:100%;">
+                    </td>
+                </tr>
+                <tr>
+                    <td>
+                        <button id="upload" type="button" onclick="upload()">Upload</button>
+                    </td>
+                </tr>
+            </table>
+            <script>
+            function setpath() {
+                var default_path = document.getElementById("newfile").files[0].name;
+                document.getElementById("filepath").value = default_path;
+            }
+            function upload() {
+                var filePath = document.getElementById("filepath").value;
+                var upload_path = "/upload/" + filePath;
+                var fileInput = document.getElementById("newfile").files;
+
+                /* Max size of an individual file. Make sure this
+                * value is same as that set in file_server.c */
+                var MAX_FILE_SIZE = 2048*1024;
+                var MAX_FILE_SIZE_STR = "2MB";
+
+                if (fileInput.length == 0) {
+                    alert("No file selected!");
+                } else if (filePath.length == 0) {
+                    alert("File path on server is not set!");
+                } else if (filePath.indexOf(' ') >= 0) {
+                    alert("File path on server cannot have spaces!");
+                } else if (filePath[filePath.length-1] == '/') {
+                    alert("File name not specified after path!");
+                } else if (fileInput[0].size > 200*1024) {
+                    alert("File size must be less than 200KB!");
+                } else {
+                    document.getElementById("newfile").disabled = true;
+                    document.getElementById("filepath").disabled = true;
+                    document.getElementById("upload").disabled = true;
+
+                    var file = fileInput[0];
+                    var xhttp = new XMLHttpRequest();
+                    xhttp.onreadystatechange = function() {
+                        if (xhttp.readyState == 4) {
+                            if (xhttp.status == 200) {
+                                document.open();
+                                document.write(xhttp.responseText);
+                                document.close();
+                            } else if (xhttp.status == 0) {
+                                alert("Server closed the connection abruptly!");
+                                location.reload()
+                            } else {
+                                alert(xhttp.status + " Error!\n" + xhttp.responseText);
+                                location.reload()
+                            }
+                        }
+                    };
+                    xhttp.open("POST", upload_path, true);
+                    xhttp.send(file);
+                }
+            }
+            </script>
+
+            <h1>Multipart POST Form</h1>
+            <form action="/multipart" method="post" enctype="multipart/form-data">
+                <label for="param1">Parameter 1:</label>
+                <input type="text" id="param1" name="param1" value="Parameter 1">            
+                <br>
+
+                <label for="param2">Parameter 2:</label>
+                <input type="text" id="param2" name="param2" value="Parameter 2">            
+                <br>
+
+                <label for="file-upload">File Upload:</label>
+                <input type="file" id="file-upload" name="file_upload" accept=".txt, .html, .pdf, .png, .jpg, .gif" required>
+                <br>
+            
+                <input type="submit" value="Upload File">
+            </form>
+
+            <h1>Websocket Demo</h1>
+            <input type="text" id="message_input" placeholder="Type your message">
+            <button onclick="sendMessage()">Send Message</button>
+            <button onclick="websocketConnect()">Connect</button>
+            <div>
+                <textarea id="websocket_output" style="width: 50%; height: 250px;"></textarea>
+            </div>
+
+            <script>
+                let socket;
+                const outputText = document.getElementById('websocket_output');
+                const messageInput = document.getElementById('message_input');
+
+                function websocketConnect()
+                {
+                    // Create a WebSocket connection
+                    socket = new WebSocket('ws://' + window.location.host + '/ws');
+            
+                    // Event handler for when the WebSocket connection is open
+                    socket.addEventListener('open', (event) => {
+                        outputText.value += `[socket] connection opened!\n`;
+                        outputText.scrollTop = outputText.scrollHeight;
+                    });
+            
+                    // Event handler for when a message is received from the WebSocket server
+                    socket.addEventListener('message', (event) => {
+                        // Echo the received message into the output div
+                        let data = event.data.trim();
+                        outputText.value += `[received] ${data}\n`;
+                        outputText.scrollTop = outputText.scrollHeight;
+                    });
+            
+                    // Event handler for when an error occurs with the WebSocket connection
+                    socket.addEventListener('error', (event) => {
+                        let data = event.data.trim();
+                        outputText.value += `[error] ${event.data}\n`;
+                        outputText.scrollTop = outputText.scrollHeight;
+                    });
+            
+                    // Event handler for when the WebSocket connection is closed
+                    socket.addEventListener('close', (event) => {
+                        outputText.value += `[socket] connection opened!\n`;
+                    });
+                }
+        
+                // Function to send a message to the WebSocket server
+                function sendMessage() {
+                    if (socket.readyState == WebSocket.OPEN) {
+                        const message = messageInput.value.trim();
+                        if (message) {
+                            socket.send(message);
+                            messageInput.value = ''; // Clear the input field after sending the message
+                            outputText.value += `[sent] ${message}\n`;
+                            outputText.scrollTop = outputText.scrollHeight;
+                        }
+                    }
+                    else
+                    {
+                        outputText.value += `[error] Not Connected\n`;
+                        outputText.scrollTop = outputText.scrollHeight;
+                    }
+                }
+            </script>
+
+            <h1>EventSource Demo</h1>
+            <button onclick="eventSourceConnect()">Connect</button>
+            <div>
+                <textarea id="eventsource_output" style="width: 50%; height: 250px;"></textarea>
+            </div>
+
+            <script>
+                const dataElement = document.getElementById('eventsource_output');
+
+                function eventSourceConnect()
+                {
+                    const eventSource = new EventSource('/events');
+            
+                    eventSource.onopen = () => {
+                        dataElement.value += `[connected]\n`;
+                        dataElement.scrollTop = dataElement.scrollHeight;
+                    };
+
+                    eventSource.addEventListener('millis', (event) => {
+                        let data = event.data.trim()
+                        dataElement.value += `[millis] ${data}\n`;
+                        dataElement.scrollTop = dataElement.scrollHeight;
+                    });
+
+                    eventSource.onmessage = (event) => {
+                        let data = event.data.trim()
+                        dataElement.value += `[message] ${data}\n`;
+                        dataElement.scrollTop = dataElement.scrollHeight;
+                    };
+                
+                    eventSource.onerror = (error) => {
+                        dataElement.value += `[error] ${error}\n`;
+                        dataElement.scrollTop = dataElement.scrollHeight;
+                        eventSource.close();
+                    };
+                }
+              </script>
+        </main>
+    </body>
+</html>

lib/PsychicHttp/examples/esp-idf/data/www/text.txt

@@ -0,0 +1 @@
+Test File.

lib/PsychicHttp/examples/esp-idf/include/README

@@ -0,0 +1,39 @@
+
+This directory is intended for project header files.
+
+A header file is a file containing C declarations and macro definitions
+to be shared between several project source files. You request the use of a
+header file in your project source file (C, C++, etc) located in `src` folder
+by including it, with the C preprocessing directive `#include'.
+
+```src/main.c
+
+#include "header.h"
+
+int main (void)
+{
+ ...
+}
+```
+
+Including a header file produces the same results as copying the header file
+into each source file that needs it. Such copying would be time-consuming
+and error-prone. With a header file, the related declarations appear
+in only one place. If they need to be changed, they can be changed in one
+place, and programs that include the header file will automatically use the
+new version when next recompiled. The header file eliminates the labor of
+finding and changing all the copies as well as the risk that a failure to
+find one copy will result in inconsistencies within a program.
+
+In C, the usual convention is to give header files names that end with `.h'.
+It is most portable to use only letters, digits, dashes, and underscores in
+header file names, and at most one dot.
+
+Read more about using header files in official GCC documentation:
+
+* Include Syntax
+* Include Operation
+* Once-Only Headers
+* Computed Includes
+
+https://gcc.gnu.org/onlinedocs/cpp/Header-Files.html

lib/PsychicHttp/examples/esp-idf/lib/README

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

lib/PsychicHttp/examples/esp-idf/main/CMakeLists.txt

@@ -0,0 +1,8 @@
+# This file was automatically generated for projects
+# without default 'CMakeLists.txt' file.
+
+idf_component_register(
+    SRCS "main.cpp"
+    INCLUDE_DIRS ".")
+
+littlefs_create_partition_image(littlefs ${project_dir}/data)