Merge pull request #22 from gagulik/serveStatic_dev2

streamFile and serveStatic for ESP8266/ESP32 boards

Author: khoih-prog

examples/serveStatic/defines.h

@@ -42,8 +42,8 @@
 
   // For ESP8266
   #include <FS.h>
-  #include <LittleFS.h>
-  
+  #include <LittleFS.h
+
   #warning Use ESP8266 architecture
   #include <ESP8266mDNS.h>
   #define ETHERNET_USE_ESP8266

examples/serveStatic/serveStatic.ino

@@ -6,7 +6,6 @@
   https://www.qrz.com/db/ac8l
 
   Prior to the usage - use ESP8266/ESP32 Sketch data upoad tool to save the content of web-site to the SPIFFS flash memory.
-
   This example sketch is based on HTML templates from Robert Ulbricht: https://www.arduinoslovakia.eu
   https://github.com/RoboUlbricht/arduinoslovakia/tree/master/esp8266/simple_http_server_multiplepages_responsive_spiffs
 
@@ -20,7 +19,7 @@
   Based on and modified from ESP8266 https://github.com/esp8266/Arduino/releases
   Built by Khoi Hoang https://github.com/khoih-prog/EthernetWebServer
   Licensed under MIT license
- *****************************************************************************************************************************/
+ *****************************************************************************************************************************
 /*****************************************************************************************************************************
    The Arduino board communicates with the shield using the SPI bus. This is on digital pins 11, 12, and 13 on the Uno
    and pins 50, 51, and 52 on the Mega. On both boards, pin 10 is used as SS. On the Mega, the hardware SS pin, 53,
@@ -52,7 +51,7 @@ void setup(void)
   EthernetInit();
 
 #else
-
+  
   #if USE_NATIVE_ETHERNET
     ET_LOGWARN(F("======== USE_NATIVE_ETHERNET ========"));
   #elif USE_ETHERNET
@@ -77,7 +76,7 @@ void setup(void)
   ET_LOGWARN1(F("SCK:"),  SCK);
   ET_LOGWARN1(F("SS:"),   SS);
   ET_LOGWARN(F("========================="));
-
+  
   #if defined(ESP8266)
     // For ESP8266, change for other boards if necessary
     #ifndef USE_THIS_SS_PIN

src/EthernetWebServer-impl.h

@@ -664,6 +664,24 @@ void EthernetWebServer::sendContent_P(PGM_P content, size_t size)
   }
 }
 //////
+#if (ESP32 || ESP8266)
+#include "FS.h"
+void EthernetWebServer::serveStatic(const char* uri, FS& fs, const char* path, const char* cache_header) {
+    _addRequestHandler(new StaticFileRequestHandler(fs, path, uri, cache_header));
+}
+
+void EthernetWebServer::_streamFileCore(const size_t fileSize, const String &fileName, const String &contentType)
+{
+  using namespace mime;
+  setContentLength(fileSize);
+  if (fileName.endsWith(String(FPSTR(mimeTable[gz].endsWith))) &&
+      contentType != String(FPSTR(mimeTable[gz].mimeType)) &&
+      contentType != String(FPSTR(mimeTable[none].mimeType))) {
+    sendHeader(F("Content-Encoding"), F("gzip"));
+  }
+  send(200, contentType, emptyString);
+}
+#endif
 
 String EthernetWebServer::arg(String name) 
 {

src/EthernetWebServer.h

@@ -186,6 +186,9 @@ typedef struct
 } HTTPUpload;
 
 #include "detail/RequestHandler.h"
+#if (ESP32 || ESP8266)
+    #include "FS.h"
+#endif
 
 class EthernetWebServer
 {
@@ -279,6 +282,7 @@ class EthernetWebServer
 
     static String urlDecode(const String& text);
 
+    #if !(ESP32 || ESP8266)
     template<typename T> size_t streamFile(T &file, const String& contentType) 
     {
       using namespace mime;
@@ -293,6 +297,27 @@ class EthernetWebServer
 
       return _currentClient.write(file);
     }
+    #else
+    void serveStatic(const char* uri, fs::FS& fs, const char* path, const char* cache_header = NULL ); // serve static pages from file system
+
+    // Handle a GET request by sending a response header and stream file content to response body
+      template<typename T>
+      size_t streamFile(T &file, const String& contentType) {
+        return streamFile(file, contentType, HTTP_GET);
+      }
+
+      // Implement GET and HEAD requests for files.
+      // Stream body on HTTP_GET but not on HTTP_HEAD requests.
+      template<typename T>
+      size_t streamFile(T &file, const String& contentType, HTTPMethod requestMethod) {
+        size_t contentLength = 0;
+        _streamFileCore(file.size(), file.name(), contentType);
+        if (requestMethod == HTTP_GET) {
+            contentLength = _customClientWrite(file);
+        }
+        return contentLength;
+      }
+    #endif
 
   protected:
     void _addRequestHandler(RequestHandler* handler);
@@ -316,7 +341,27 @@ class EthernetWebServer
     uint8_t _uploadReadByte(EthernetClient& client);
     void _prepareHeader(String& response, int code, const char* content_type, size_t contentLength);
     bool _collectHeader(const char* headerName, const char* headerValue);
-
+    
+    #if (ESP32 || ESP8266)
+    void _streamFileCore(const size_t fileSize, const String & fileName, const String & contentType);
+
+    template<typename T>
+    size_t _customClientWrite(T &file) {
+        char buffer[256];
+        size_t contentLength = 0;
+        size_t bytesRead = 0;
+
+        // read up to sizeof(buffer) bytes
+          while ((bytesRead = file.readBytes(buffer, sizeof(buffer))) > 0)
+          {
+              _currentClient.write(buffer, bytesRead);
+              contentLength += bytesRead;
+          }
+
+        return contentLength;
+    }
+    #endif
+    
     struct RequestArgument {
 
       String key;

src/detail/ESP_RequestHandlersImpl.h

@@ -0,0 +1,191 @@
+/****************************************************************************************************************************
+   ESP_RequestHandlersImpl.h - Dead simple web-server.
+   For Ethernet shields on ESP8266 and ESP32
+   For EthernetWebServer library by Khoi Hoang
+ 
+   EthernetWebServer is a library for the Ethernet shields to run WebServer
+
+   Based on and modified from ESP8266 https://github.com/esp8266/Arduino/releases
+   Built by Khoi Hoang https://github.com/khoih-prog/EthernetWebServer
+   Licensed under MIT license
+   Version: 1.0.0
+
+   Original author:
+   @file       RequestHandlersImpl.h
+   @author     Khoi Hoang
+
+   Version Modified By   Date      Comments
+   ------- -----------  ---------- -----------
+    1.0.0   S Azari      25/01/2021 Initial coding, inheriting EthernetWebServer class and porting ESP8266 code
+ *****************************************************************************************************************************/
+
+#pragma once
+
+#include "RequestHandler.h"
+#include "esp_detail/mimetable.h"
+#include "FS.h"
+#include "WString.h"
+#include <MD5Builder.h>
+#include <base64.h>
+
+class FunctionRequestHandler : public RequestHandler
+{
+  public:
+
+    FunctionRequestHandler(EthernetWebServer::THandlerFunction fn, EthernetWebServer::THandlerFunction ufn, const String &uri, HTTPMethod method)
+      : _fn(fn)
+      , _ufn(ufn)
+      , _uri(uri)
+      , _method(method)
+    {
+    }
+
+    bool canHandle(HTTPMethod requestMethod, String requestUri) override
+    {
+      if (_method != HTTP_ANY && _method != requestMethod)
+        return false;
+
+      if (requestUri == _uri)
+        return true;
+
+      if (_uri.endsWith("/*"))
+      {
+        String _uristart = _uri;
+        _uristart.replace("/*", "");
+
+        if (requestUri.startsWith(_uristart))
+          return true;
+      }
+
+      return false;
+    }
+
+    bool canUpload(String requestUri) override
+    {
+      if (!_ufn || !canHandle(HTTP_POST, requestUri))
+        return false;
+
+      return true;
+    }
+
+    bool handle(EthernetWebServer& server, HTTPMethod requestMethod, String requestUri) override
+    {
+      ETW_UNUSED(server);
+      
+      if (!canHandle(requestMethod, requestUri))
+        return false;
+
+      _fn();
+      return true;
+    }
+
+    void upload(EthernetWebServer& server, String requestUri, HTTPUpload& upload) override
+    {
+      ETW_UNUSED(server);
+      ETW_UNUSED(upload);
+      
+      if (canUpload(requestUri))
+        _ufn();
+    }
+
+  protected:
+    EthernetWebServer::THandlerFunction _fn;
+    EthernetWebServer::THandlerFunction _ufn;
+    String _uri;
+    HTTPMethod _method;
+};
+
+class StaticRequestHandler : public RequestHandler {
+    using WebServerType = EthernetWebServer;
+public:
+    StaticRequestHandler(FS& fs, const char* path, const char* uri, const char* cache_header)
+    : _fs(fs)
+    , _uri(uri)
+    , _path(path)
+    , _cache_header(cache_header)
+    {
+        //DEBUGV("StaticRequestHandler: path=%s uri=%s, cache_header=%s\r\n", path, uri, cache_header == __null ? "" : cache_header);
+        _isFile = fs.exists(path);
+        _baseUriLength = _uri.length();
+    }
+
+    bool validMethod(HTTPMethod requestMethod){
+        return (requestMethod == HTTP_GET) || (requestMethod == HTTP_HEAD);
+    }
+
+    /* Deprecated version. Please use mime::getContentType instead */
+    static String getContentType(const String& path) __attribute__((deprecated)) {
+        return mime_esp::getContentType(path);
+    }
+
+protected:
+    FS _fs;
+    bool _isFile;
+    String _uri;
+    String _path;
+    String _cache_header;
+    size_t _baseUriLength;
+};
+
+
+class StaticFileRequestHandler
+    :
+public StaticRequestHandler {
+
+    using SRH = StaticRequestHandler;
+    using WebServerType = EthernetWebServer;
+
+public:
+    StaticFileRequestHandler(FS& fs, const char* path, const char* uri, const char* cache_header)
+        :
+    StaticRequestHandler{fs, path, uri, cache_header}
+    {
+        File f = SRH::_fs.open(path, "r");
+        MD5Builder calcMD5;
+        calcMD5.begin();
+        calcMD5.addStream(f, f.size());
+        calcMD5.calculate();
+        calcMD5.getBytes(_ETag_md5);
+        f.close();
+    }
+
+    bool canHandle(HTTPMethod requestMethod, const String requestUri) override  {
+        return SRH::validMethod(requestMethod) && requestUri == SRH::_uri;
+    }
+
+    bool handle(EthernetWebServer& server, HTTPMethod requestMethod, const String requestUri) {
+
+        if (!canHandle(requestMethod, requestUri))
+            return false;
+
+        
+        const String etag = "\"" + base64::encode(_ETag_md5, 16) + "\"";
+
+        if(server.header("If-None-Match") == etag){
+            server.send(304);
+            return true;
+        }
+
+        File f = SRH::_fs.open(SRH::_path, "r");
+
+        if (!f)
+            return false;
+
+        if (!_isFile) {
+            f.close();
+            return false;
+        }
+
+        if (SRH::_cache_header.length() != 0)
+            server.sendHeader("Cache-Control", SRH::_cache_header);
+
+        server.sendHeader("ETag", etag);
+
+        server.streamFile(f, mime_esp::getContentType(SRH::_path), requestMethod);
+        return true;
+    }
+
+protected:
+    uint8_t _ETag_md5[16];
+};
+

src/detail/RequestHandlersImpl.h

@@ -38,6 +38,7 @@
 
 #pragma once
 
+#if !(ESP32 || ESP8266)
 #include "RequestHandler.h"
 #include "mimetable.h"
 
@@ -187,3 +188,6 @@ class StaticRequestHandler : public RequestHandler
     size_t _baseUriLength;
 };
 
+#else
+#include "ESP_RequestHandlersImpl.h"
+#endif