feat: added support for filters in webserver

ayushsharma82 · ayushsharma82 · commit 8dbf85e1a8cb · 2024-06-12T21:54:25.000+05:30
diff --git a/libraries/WebServer/src/Parsing.cpp b/libraries/WebServer/src/Parsing.cpp
@@ -124,7 +124,7 @@ bool WebServer::_parseRequest(NetworkClient &client) {
   //attach handler
   RequestHandler *handler;
   for (handler = _firstHandler; handler; handler = handler->next()) {
-    if (handler->canHandle(_currentMethod, _currentUri)) {
+    if (handler->canHandle(*this, _currentMethod, _currentUri)) {
       break;
     }
   }
@@ -176,7 +176,7 @@ bool WebServer::_parseRequest(NetworkClient &client) {
       }
     }
 
-    if (!isForm && _currentHandler && _currentHandler->canRaw(_currentUri)) {
+    if (!isForm && _currentHandler && _currentHandler->canRaw(*this, _currentUri)) {
       log_v("Parse raw");
       _currentRaw.reset(new HTTPRaw());
       _currentRaw->status = RAW_START;
@@ -334,7 +334,7 @@ void WebServer::_parseArguments(String data) {
 
 void WebServer::_uploadWriteByte(uint8_t b) {
   if (_currentUpload->currentSize == HTTP_UPLOAD_BUFLEN) {
-    if (_currentHandler && _currentHandler->canUpload(_currentUri)) {
+    if (_currentHandler && _currentHandler->canUpload(*this, _currentUri)) {
       _currentHandler->upload(*this, _currentUri, *_currentUpload);
     }
     _currentUpload->totalSize += _currentUpload->currentSize;
@@ -449,7 +449,7 @@ bool WebServer::_parseForm(NetworkClient &client, String boundary, uint32_t len)
             _currentUpload->totalSize = 0;
             _currentUpload->currentSize = 0;
             log_v("Start File: %s Type: %s", _currentUpload->filename.c_str(), _currentUpload->type.c_str());
-            if (_currentHandler && _currentHandler->canUpload(_currentUri)) {
+            if (_currentHandler && _currentHandler->canUpload(*this, _currentUri)) {
               _currentHandler->upload(*this, _currentUri, *_currentUpload);
             }
             _currentUpload->status = UPLOAD_FILE_WRITE;
@@ -488,12 +488,12 @@ bool WebServer::_parseForm(NetworkClient &client, String boundary, uint32_t len)
               }
             }
             // Found the boundary string, finish processing this file upload
-            if (_currentHandler && _currentHandler->canUpload(_currentUri)) {
+            if (_currentHandler && _currentHandler->canUpload(*this, _currentUri)) {
               _currentHandler->upload(*this, _currentUri, *_currentUpload);
             }
             _currentUpload->totalSize += _currentUpload->currentSize;
             _currentUpload->status = UPLOAD_FILE_END;
-            if (_currentHandler && _currentHandler->canUpload(_currentUri)) {
+            if (_currentHandler && _currentHandler->canUpload(*this, _currentUri)) {
               _currentHandler->upload(*this, _currentUri, *_currentUpload);
             }
             log_v("End File: %s Type: %s Size: %d", _currentUpload->filename.c_str(), _currentUpload->type.c_str(), (int)_currentUpload->totalSize);
@@ -567,7 +567,7 @@ String WebServer::urlDecode(const String &text) {
 
 bool WebServer::_parseFormUploadAborted() {
   _currentUpload->status = UPLOAD_FILE_ABORTED;
-  if (_currentHandler && _currentHandler->canUpload(_currentUri)) {
+  if (_currentHandler && _currentHandler->canUpload(*this, _currentUri)) {
     _currentHandler->upload(*this, _currentUri, *_currentUpload);
   }
   return false;
diff --git a/libraries/WebServer/src/WebServer.cpp b/libraries/WebServer/src/WebServer.cpp
@@ -306,16 +306,18 @@ void WebServer::requestAuthentication(HTTPAuthMethod mode, const char *realm, co
   send(401, String(FPSTR(mimeTable[html].mimeType)), authFailMsg);
 }
 
-void WebServer::on(const Uri &uri, WebServer::THandlerFunction handler) {
-  on(uri, HTTP_ANY, handler);
+RequestHandler& WebServer::on(const Uri &uri, WebServer::THandlerFunction handler) {
+  return on(uri, HTTP_ANY, handler);
 }
 
-void WebServer::on(const Uri &uri, HTTPMethod method, WebServer::THandlerFunction fn) {
-  on(uri, method, fn, _fileUploadHandler);
+RequestHandler& WebServer::on(const Uri &uri, HTTPMethod method, WebServer::THandlerFunction fn) {
+  return on(uri, method, fn, _fileUploadHandler);
 }
 
-void WebServer::on(const Uri &uri, HTTPMethod method, WebServer::THandlerFunction fn, WebServer::THandlerFunction ufn) {
-  _addRequestHandler(new FunctionRequestHandler(fn, ufn, uri, method));
+RequestHandler& WebServer::on(const Uri &uri, HTTPMethod method, WebServer::THandlerFunction fn, WebServer::THandlerFunction ufn) {
+  FunctionRequestHandler *handler = new FunctionRequestHandler(fn, ufn, uri, method);
+  _addRequestHandler(handler);
+  return *handler;
 }
 
 void WebServer::addHandler(RequestHandler *handler) {
@@ -796,3 +798,14 @@ String WebServer::_responseCodeToString(int code) {
     default:  return F("");
   }
 }
+
+bool ON_STA_FILTER(WebServer &server) {
+  return (
+    (WiFi.localIP() != IPAddress(0, 0, 0, 0) && server.client().localIP() != IPAddress(0, 0, 0, 0))
+    && WiFi.localIP() == server.client().localIP()
+  );
+}
+
+bool ON_AP_FILTER(WebServer &server) {
+  return WiFi.localIP() == server.client().localIP();
+}
diff --git a/libraries/WebServer/src/WebServer.h b/libraries/WebServer/src/WebServer.h
@@ -26,6 +26,7 @@
 #include <functional>
 #include <memory>
 #include "FS.h"
+#include "WiFi.h"
 #include "Network.h"
 #include "HTTP_Method.h"
 #include "Uri.h"
@@ -144,9 +145,10 @@ class WebServer {
   void requestAuthentication(HTTPAuthMethod mode = BASIC_AUTH, const char *realm = NULL, const String &authFailMsg = String(""));
 
   typedef std::function<void(void)> THandlerFunction;
-  void on(const Uri &uri, THandlerFunction fn);
-  void on(const Uri &uri, HTTPMethod method, THandlerFunction fn);
-  void on(const Uri &uri, HTTPMethod method, THandlerFunction fn, THandlerFunction ufn);  //ufn handles file uploads
+  typedef std::function<bool(WebServer &server)> FilterFunction;
+  RequestHandler& on(const Uri &uri, THandlerFunction fn);
+  RequestHandler& on(const Uri &uri, HTTPMethod method, THandlerFunction fn);
+  RequestHandler& on(const Uri &uri, HTTPMethod method, THandlerFunction fn, THandlerFunction ufn);  //ufn handles file uploads
   void addHandler(RequestHandler *handler);
   void serveStatic(const char *uri, fs::FS &fs, const char *path, const char *cache_header = NULL);
   void onNotFound(THandlerFunction fn);     //called when handler is not assigned
@@ -292,4 +294,12 @@ class WebServer {
   String _srealm;  // Store the Auth realm between Calls
 };
 
+/*
+  Request Filters
+*/
+
+bool ON_STA_FILTER(WebServer &server);
+
+bool ON_AP_FILTER(WebServer &server);
+
 #endif  //ESP8266WEBSERVER_H
diff --git a/libraries/WebServer/src/detail/RequestHandler.h b/libraries/WebServer/src/detail/RequestHandler.h
@@ -7,16 +7,19 @@
 class RequestHandler {
 public:
   virtual ~RequestHandler() {}
-  virtual bool canHandle(HTTPMethod method, String uri) {
+  virtual bool canHandle(WebServer &server, HTTPMethod method, String uri) {
+    (void)server;
     (void)method;
     (void)uri;
     return false;
   }
-  virtual bool canUpload(String uri) {
+  virtual bool canUpload(WebServer &server, String uri) {
+    (void)server;
     (void)uri;
     return false;
   }
-  virtual bool canRaw(String uri) {
+  virtual bool canRaw(WebServer &server, String uri) {
+    (void)server;
     (void)uri;
     return false;
   }
@@ -37,6 +40,11 @@ class RequestHandler {
     (void)raw;
   }
 
+  virtual RequestHandler& setFilter(std::function<bool(WebServer&)> filter) {
+    (void)filter;
+    return *this;
+  }
+
   RequestHandler *next() {
     return _next;
   }
diff --git a/libraries/WebServer/src/detail/RequestHandlersImpl.h b/libraries/WebServer/src/detail/RequestHandlersImpl.h
@@ -21,32 +21,32 @@ class FunctionRequestHandler : public RequestHandler {
     delete _uri;
   }
 
-  bool canHandle(HTTPMethod requestMethod, String requestUri) override {
+  bool canHandle(WebServer &server, HTTPMethod requestMethod, String requestUri) override {
     if (_method != HTTP_ANY && _method != requestMethod) {
       return false;
     }
 
-    return _uri->canHandle(requestUri, pathArgs);
+    return _uri->canHandle(requestUri, pathArgs) && (_filter != NULL ? _filter(server) : true);
   }
 
-  bool canUpload(String requestUri) override {
-    if (!_ufn || !canHandle(HTTP_POST, requestUri)) {
+  bool canUpload(WebServer &server, String requestUri) override {
+    if (!_ufn || !canHandle(server, HTTP_POST, requestUri)) {
       return false;
     }
 
     return true;
   }
-  bool canRaw(String requestUri) override {
-    if (!_ufn || _method == HTTP_GET) {
+
+  bool canRaw(WebServer &server, String requestUri) override {
+    if (!_ufn || _method == HTTP_GET || (_filter != NULL ? _filter(server) == false : false)) {
       return false;
     }
 
     return true;
   }
 
   bool handle(WebServer &server, HTTPMethod requestMethod, String requestUri) override {
-    (void)server;
-    if (!canHandle(requestMethod, requestUri)) {
+    if (!canHandle(server, requestMethod, requestUri)) {
       return false;
     }
 
@@ -55,24 +55,30 @@ class FunctionRequestHandler : public RequestHandler {
   }
 
   void upload(WebServer &server, String requestUri, HTTPUpload &upload) override {
-    (void)server;
     (void)upload;
-    if (canUpload(requestUri)) {
+    if (canUpload(server, requestUri)) {
       _ufn();
     }
   }
 
   void raw(WebServer &server, String requestUri, HTTPRaw &raw) override {
-    (void)server;
     (void)raw;
-    if (canRaw(requestUri)) {
+    if (canRaw(server, requestUri)) {
       _ufn();
     }
   }
 
+  FunctionRequestHandler& setFilter(WebServer::FilterFunction filter) {
+    _filter = filter;
+    return *this;
+  }
+
 protected:
   WebServer::THandlerFunction _fn;
   WebServer::THandlerFunction _ufn;
+  // _filter should return 'true' when the request should be handled
+  // and 'false' when the request should be ignored
+  WebServer::FilterFunction _filter;
   Uri *_uri;
   HTTPMethod _method;
 };
@@ -88,7 +94,7 @@ class StaticRequestHandler : public RequestHandler {
     _baseUriLength = _uri.length();
   }
 
-  bool canHandle(HTTPMethod requestMethod, String requestUri) override {
+  bool canHandle(WebServer &server, HTTPMethod requestMethod, String requestUri) override {
     if (requestMethod != HTTP_GET) {
       return false;
     }
@@ -97,11 +103,15 @@ class StaticRequestHandler : public RequestHandler {
       return false;
     }
 
+    if (_filter != NULL ? _filter(server) == false : false) {
+      return false;
+    }
+
     return true;
   }
 
   bool handle(WebServer &server, HTTPMethod requestMethod, String requestUri) override {
-    if (!canHandle(requestMethod, requestUri)) {
+    if (!canHandle(server, requestMethod, requestUri)) {
       return false;
     }
 
@@ -198,6 +208,7 @@ class StaticRequestHandler : public RequestHandler {
   }  // calcETag
 
 protected:
+  WebServer::FilterFunction _filter;
   FS _fs;
   String _uri;
   String _path;

Original file line number	Diff line number	Diff line change
`@@ -124,7 +124,7 @@ bool WebServer::_parseRequest(NetworkClient &client) {`
`124`	`124`	`//attach handler`
`125`	`125`	`RequestHandler *handler;`
`126`	`126`	`for (handler = _firstHandler; handler; handler = handler->next()) {`
`127`		`- if (handler->canHandle(_currentMethod, _currentUri)) {`
	`127`	`+ if (handler->canHandle(*this, _currentMethod, _currentUri)) {`
`128`	`128`	`break;`
`129`	`129`	`}`
`130`	`130`	`}`
`@@ -176,7 +176,7 @@ bool WebServer::_parseRequest(NetworkClient &client) {`
`176`	`176`	`}`
`177`	`177`	`}`
`178`	`178`
`179`		`- if (!isForm && _currentHandler && _currentHandler->canRaw(_currentUri)) {`
	`179`	`+ if (!isForm && _currentHandler && _currentHandler->canRaw(*this, _currentUri)) {`
`180`	`180`	`log_v("Parse raw");`
`181`	`181`	`_currentRaw.reset(new HTTPRaw());`
`182`	`182`	`_currentRaw->status = RAW_START;`
`@@ -334,7 +334,7 @@ void WebServer::_parseArguments(String data) {`
`334`	`334`
`335`	`335`	`void WebServer::_uploadWriteByte(uint8_t b) {`
`336`	`336`	`if (_currentUpload->currentSize == HTTP_UPLOAD_BUFLEN) {`
`337`		`- if (_currentHandler && _currentHandler->canUpload(_currentUri)) {`
	`337`	`+ if (_currentHandler && _currentHandler->canUpload(*this, _currentUri)) {`
`338`	`338`	`_currentHandler->upload(this, _currentUri, _currentUpload);`
`339`	`339`	`}`
`340`	`340`	`_currentUpload->totalSize += _currentUpload->currentSize;`
`@@ -449,7 +449,7 @@ bool WebServer::_parseForm(NetworkClient &client, String boundary, uint32_t len)`
`449`	`449`	`_currentUpload->totalSize = 0;`
`450`	`450`	`_currentUpload->currentSize = 0;`
`451`	`451`	`log_v("Start File: %s Type: %s", _currentUpload->filename.c_str(), _currentUpload->type.c_str());`
`452`		`- if (_currentHandler && _currentHandler->canUpload(_currentUri)) {`
	`452`	`+ if (_currentHandler && _currentHandler->canUpload(*this, _currentUri)) {`
`453`	`453`	`_currentHandler->upload(this, _currentUri, _currentUpload);`
`454`	`454`	`}`
`455`	`455`	`_currentUpload->status = UPLOAD_FILE_WRITE;`
`@@ -488,12 +488,12 @@ bool WebServer::_parseForm(NetworkClient &client, String boundary, uint32_t len)`
`488`	`488`	`}`
`489`	`489`	`}`
`490`	`490`	`// Found the boundary string, finish processing this file upload`
`491`		`- if (_currentHandler && _currentHandler->canUpload(_currentUri)) {`
	`491`	`+ if (_currentHandler && _currentHandler->canUpload(*this, _currentUri)) {`
`492`	`492`	`_currentHandler->upload(this, _currentUri, _currentUpload);`
`493`	`493`	`}`
`494`	`494`	`_currentUpload->totalSize += _currentUpload->currentSize;`
`495`	`495`	`_currentUpload->status = UPLOAD_FILE_END;`
`496`		`- if (_currentHandler && _currentHandler->canUpload(_currentUri)) {`
	`496`	`+ if (_currentHandler && _currentHandler->canUpload(*this, _currentUri)) {`
`497`	`497`	`_currentHandler->upload(this, _currentUri, _currentUpload);`
`498`	`498`	`}`
`499`	`499`	`log_v("End File: %s Type: %s Size: %d", _currentUpload->filename.c_str(), _currentUpload->type.c_str(), (int)_currentUpload->totalSize);`
`@@ -567,7 +567,7 @@ String WebServer::urlDecode(const String &text) {`
`567`	`567`
`568`	`568`	`bool WebServer::_parseFormUploadAborted() {`
`569`	`569`	`_currentUpload->status = UPLOAD_FILE_ABORTED;`
`570`		`- if (_currentHandler && _currentHandler->canUpload(_currentUri)) {`
	`570`	`+ if (_currentHandler && _currentHandler->canUpload(*this, _currentUri)) {`
`571`	`571`	`_currentHandler->upload(this, _currentUri, _currentUpload);`
`572`	`572`	`}`
`573`	`573`	`return false;`
Original file line number	Diff line number	Diff line change
`@@ -21,32 +21,32 @@ class FunctionRequestHandler : public RequestHandler {`
`21`	`21`	`delete _uri;`
`22`	`22`	`}`
`23`	`23`
`24`		`- bool canHandle(HTTPMethod requestMethod, String requestUri) override {`
	`24`	`+ bool canHandle(WebServer &server, HTTPMethod requestMethod, String requestUri) override {`
`25`	`25`	`if (_method != HTTP_ANY && _method != requestMethod) {`
`26`	`26`	`return false;`
`27`	`27`	`}`
`28`	`28`
`29`		`- return _uri->canHandle(requestUri, pathArgs);`
	`29`	`+ return _uri->canHandle(requestUri, pathArgs) && (_filter != NULL ? _filter(server) : true);`
`30`	`30`	`}`
`31`	`31`
`32`		`- bool canUpload(String requestUri) override {`
`33`		`- if (!_ufn \|\| !canHandle(HTTP_POST, requestUri)) {`
	`32`	`+ bool canUpload(WebServer &server, String requestUri) override {`
	`33`	`+ if (!_ufn \|\| !canHandle(server, HTTP_POST, requestUri)) {`
`34`	`34`	`return false;`
`35`	`35`	`}`
`36`	`36`
`37`	`37`	`return true;`
`38`	`38`	`}`
`39`		`- bool canRaw(String requestUri) override {`
`40`		`- if (!_ufn \|\| _method == HTTP_GET) {`
	`39`	`+`
	`40`	`+ bool canRaw(WebServer &server, String requestUri) override {`
	`41`	`+ if (!_ufn \|\| _method == HTTP_GET \|\| (_filter != NULL ? _filter(server) == false : false)) {`
`41`	`42`	`return false;`
`42`	`43`	`}`
`43`	`44`
`44`	`45`	`return true;`
`45`	`46`	`}`
`46`	`47`
`47`	`48`	`bool handle(WebServer &server, HTTPMethod requestMethod, String requestUri) override {`
`48`		`- (void)server;`
`49`		`- if (!canHandle(requestMethod, requestUri)) {`
	`49`	`+ if (!canHandle(server, requestMethod, requestUri)) {`
`50`	`50`	`return false;`
`51`	`51`	`}`
`52`	`52`
`@@ -55,24 +55,30 @@ class FunctionRequestHandler : public RequestHandler {`
`55`	`55`	`}`
`56`	`56`
`57`	`57`	`void upload(WebServer &server, String requestUri, HTTPUpload &upload) override {`
`58`		`- (void)server;`
`59`	`58`	`(void)upload;`
`60`		`- if (canUpload(requestUri)) {`
	`59`	`+ if (canUpload(server, requestUri)) {`
`61`	`60`	`_ufn();`
`62`	`61`	`}`
`63`	`62`	`}`
`64`	`63`
`65`	`64`	`void raw(WebServer &server, String requestUri, HTTPRaw &raw) override {`
`66`		`- (void)server;`
`67`	`65`	`(void)raw;`
`68`		`- if (canRaw(requestUri)) {`
	`66`	`+ if (canRaw(server, requestUri)) {`
`69`	`67`	`_ufn();`
`70`	`68`	`}`
`71`	`69`	`}`
`72`	`70`
	`71`	`+ FunctionRequestHandler& setFilter(WebServer::FilterFunction filter) {`
	`72`	`+ _filter = filter;`
	`73`	`+ return *this;`
	`74`	`+ }`
	`75`	`+`
`73`	`76`	`protected:`
`74`	`77`	`WebServer::THandlerFunction _fn;`
`75`	`78`	`WebServer::THandlerFunction _ufn;`
	`79`	`+ // _filter should return 'true' when the request should be handled`
	`80`	`+ // and 'false' when the request should be ignored`
	`81`	`+ WebServer::FilterFunction _filter;`
`76`	`82`	`Uri *_uri;`
`77`	`83`	`HTTPMethod _method;`
`78`	`84`	`};`
`@@ -88,7 +94,7 @@ class StaticRequestHandler : public RequestHandler {`
`88`	`94`	`_baseUriLength = _uri.length();`
`89`	`95`	`}`
`90`	`96`
`91`		`- bool canHandle(HTTPMethod requestMethod, String requestUri) override {`
	`97`	`+ bool canHandle(WebServer &server, HTTPMethod requestMethod, String requestUri) override {`
`92`	`98`	`if (requestMethod != HTTP_GET) {`
`93`	`99`	`return false;`
`94`	`100`	`}`
`@@ -97,11 +103,15 @@ class StaticRequestHandler : public RequestHandler {`
`97`	`103`	`return false;`
`98`	`104`	`}`
`99`	`105`
	`106`	`+ if (_filter != NULL ? _filter(server) == false : false) {`
	`107`	`+ return false;`
	`108`	`+ }`
	`109`	`+`
`100`	`110`	`return true;`
`101`	`111`	`}`
`102`	`112`
`103`	`113`	`bool handle(WebServer &server, HTTPMethod requestMethod, String requestUri) override {`
`104`		`- if (!canHandle(requestMethod, requestUri)) {`
	`114`	`+ if (!canHandle(server, requestMethod, requestUri)) {`
`105`	`115`	`return false;`
`106`	`116`	`}`
`107`	`117`
`@@ -198,6 +208,7 @@ class StaticRequestHandler : public RequestHandler {`
`198`	`208`	`} // calcETag`
`199`	`209`
`200`	`210`	`protected:`
	`211`	`+ WebServer::FilterFunction _filter;`
`201`	`212`	`FS _fs;`
`202`	`213`	`String _uri;`
`203`	`214`	`String _path;`