andry/EMS-ESP32
1
0
Fork 0
mirror of https://github.com/emsesp/EMS-ESP32.git synced 2025-12-06 15:59:52 +03:00
Code Issues Packages Projects Releases Wiki Activity

auto formatting

Browse Source
This commit is contained in:
proddy
2020-11-23 13:12:20 +01:00
parent 3f0c40d86c
commit d9df0bb996
39 changed files with 1521 additions and 1600 deletions
Download Patch File Download Diff File Expand all files Collapse all files

20
lib/framework/APSettingsService.cpp
View File

@@ -1,12 +1,12 @@
#include <APSettingsService.h> #include <APSettingsService.h>
APSettingsService::APSettingsService(AsyncWebServer* server, FS* fs, SecurityManager* securityManager) : APSettingsService::APSettingsService(AsyncWebServer * server, FS * fs, SecurityManager * securityManager)
_httpEndpoint(APSettings::read, APSettings::update, this, server, AP_SETTINGS_SERVICE_PATH, securityManager), : _httpEndpoint(APSettings::read, APSettings::update, this, server, AP_SETTINGS_SERVICE_PATH, securityManager)
_fsPersistence(APSettings::read, APSettings::update, this, fs, AP_SETTINGS_FILE), , _fsPersistence(APSettings::read, APSettings::update, this, fs, AP_SETTINGS_FILE)
_dnsServer(nullptr), , _dnsServer(nullptr)
_lastManaged(0), , _lastManaged(0)
_reconfigureAp(false) { , _reconfigureAp(false) {
addUpdateHandler([&](const String& originId) { reconfigureAP(); }, false); addUpdateHandler([&](const String & originId) { reconfigureAP(); }, false);
} }
void APSettingsService::begin() { void APSettingsService::begin() {
@@ -31,13 +31,11 @@ void APSettingsService::loop() {
void APSettingsService::manageAP() { void APSettingsService::manageAP() {
WiFiMode_t currentWiFiMode = WiFi.getMode(); WiFiMode_t currentWiFiMode = WiFi.getMode();
if (_state.provisionMode == AP_MODE_ALWAYS || if (_state.provisionMode == AP_MODE_ALWAYS || (_state.provisionMode == AP_MODE_DISCONNECTED && WiFi.status() != WL_CONNECTED)) {
(_state.provisionMode == AP_MODE_DISCONNECTED && WiFi.status() != WL_CONNECTED)) {
if (_reconfigureAp || currentWiFiMode == WIFI_OFF || currentWiFiMode == WIFI_STA) { if (_reconfigureAp || currentWiFiMode == WIFI_OFF || currentWiFiMode == WIFI_STA) {
startAP(); startAP();
} }
} else if ((currentWiFiMode == WIFI_AP || currentWiFiMode == WIFI_AP_STA) && } else if ((currentWiFiMode == WIFI_AP || currentWiFiMode == WIFI_AP_STA) && (_reconfigureAp || !WiFi.softAPgetStationNum())) {
(_reconfigureAp || !WiFi.softAPgetStationNum())) {
stopAP(); stopAP();
} }
_reconfigureAp = false; _reconfigureAp = false;

14
lib/framework/APSettingsService.h
View File

@@ -56,12 +56,12 @@ class APSettings {
IPAddress gatewayIP; IPAddress gatewayIP;
IPAddress subnetMask; IPAddress subnetMask;
bool operator==(const APSettings& settings) const { bool operator==(const APSettings & settings) const {
return provisionMode == settings.provisionMode && ssid == settings.ssid && password == settings.password && return provisionMode == settings.provisionMode && ssid == settings.ssid && password == settings.password && localIP == settings.localIP
localIP == settings.localIP && gatewayIP == settings.gatewayIP && subnetMask == settings.subnetMask; && gatewayIP == settings.gatewayIP && subnetMask == settings.subnetMask;
} }
static void read(APSettings& settings, JsonObject& root) { static void read(APSettings & settings, JsonObject & root) {
root["provision_mode"] = settings.provisionMode; root["provision_mode"] = settings.provisionMode;
root["ssid"] = settings.ssid; root["ssid"] = settings.ssid;
root["password"] = settings.password; root["password"] = settings.password;
@@ -70,7 +70,7 @@ class APSettings {
root["subnet_mask"] = settings.subnetMask.toString(); root["subnet_mask"] = settings.subnetMask.toString();
} }
static StateUpdateResult update(JsonObject& root, APSettings& settings) { static StateUpdateResult update(JsonObject & root, APSettings & settings) {
APSettings newSettings = {}; APSettings newSettings = {};
newSettings.provisionMode = root["provision_mode"] | FACTORY_AP_PROVISION_MODE; newSettings.provisionMode = root["provision_mode"] | FACTORY_AP_PROVISION_MODE;
switch (settings.provisionMode) { switch (settings.provisionMode) {
@@ -98,7 +98,7 @@ class APSettings {
class APSettingsService : public StatefulService<APSettings> { class APSettingsService : public StatefulService<APSettings> {
public: public:
APSettingsService(AsyncWebServer* server, FS* fs, SecurityManager* securityManager); APSettingsService(AsyncWebServer * server, FS * fs, SecurityManager * securityManager);
void begin(); void begin();
void loop(); void loop();
@@ -109,7 +109,7 @@ class APSettingsService : public StatefulService<APSettings> {
FSPersistence<APSettings> _fsPersistence; FSPersistence<APSettings> _fsPersistence;
// for the captive portal // for the captive portal
DNSServer* _dnsServer; DNSServer * _dnsServer;
// for the mangement delay loop // for the mangement delay loop
volatile unsigned long _lastManaged; volatile unsigned long _lastManaged;

11
lib/framework/APStatus.cpp
View File

@@ -1,15 +1,14 @@
#include <APStatus.h> #include <APStatus.h>
APStatus::APStatus(AsyncWebServer* server, SecurityManager* securityManager, APSettingsService* apSettingsService) : APStatus::APStatus(AsyncWebServer * server, SecurityManager * securityManager, APSettingsService * apSettingsService)
_apSettingsService(apSettingsService) { : _apSettingsService(apSettingsService) {
server->on(AP_STATUS_SERVICE_PATH, server->on(AP_STATUS_SERVICE_PATH,
HTTP_GET, HTTP_GET,
securityManager->wrapRequest(std::bind(&APStatus::apStatus, this, std::placeholders::_1), securityManager->wrapRequest(std::bind(&APStatus::apStatus, this, std::placeholders::_1), AuthenticationPredicates::IS_AUTHENTICATED));
AuthenticationPredicates::IS_AUTHENTICATED));
} }
void APStatus::apStatus(AsyncWebServerRequest* request) { void APStatus::apStatus(AsyncWebServerRequest * request) {
AsyncJsonResponse* response = new AsyncJsonResponse(false, MAX_AP_STATUS_SIZE); AsyncJsonResponse * response = new AsyncJsonResponse(false, MAX_AP_STATUS_SIZE);
JsonObject root = response->getRoot(); JsonObject root = response->getRoot();
root["status"] = _apSettingsService->getAPNetworkStatus(); root["status"] = _apSettingsService->getAPNetworkStatus();

6
lib/framework/APStatus.h
View File

@@ -21,11 +21,11 @@
class APStatus { class APStatus {
public: public:
APStatus(AsyncWebServer* server, SecurityManager* securityManager, APSettingsService* apSettingsService); APStatus(AsyncWebServer * server, SecurityManager * securityManager, APSettingsService * apSettingsService);
private: private:
APSettingsService* _apSettingsService; APSettingsService * _apSettingsService;
void apStatus(AsyncWebServerRequest* request); void apStatus(AsyncWebServerRequest * request);
}; };
#endif // end APStatus_h #endif // end APStatus_h

19
lib/framework/ArduinoJsonJWT.cpp
View File

@@ -1,6 +1,7 @@
#include "ArduinoJsonJWT.h" #include "ArduinoJsonJWT.h"
ArduinoJsonJWT::ArduinoJsonJWT(String secret) : _secret(secret) { ArduinoJsonJWT::ArduinoJsonJWT(String secret)
: _secret(secret) {
} }
void ArduinoJsonJWT::setSecret(String secret) { void ArduinoJsonJWT::setSecret(String secret) {
@@ -18,7 +19,7 @@ String ArduinoJsonJWT::getSecret() {
* *
* No need to pull in additional crypto libraries - lets use what we already have. * No need to pull in additional crypto libraries - lets use what we already have.
*/ */
String ArduinoJsonJWT::sign(String& payload) { String ArduinoJsonJWT::sign(String & payload) {
unsigned char hmacResult[32]; unsigned char hmacResult[32];
{ {
#ifdef ESP32 #ifdef ESP32
@@ -26,8 +27,8 @@ String ArduinoJsonJWT::sign(String& payload) {
mbedtls_md_type_t md_type = MBEDTLS_MD_SHA256; mbedtls_md_type_t md_type = MBEDTLS_MD_SHA256;
mbedtls_md_init(&ctx); mbedtls_md_init(&ctx);
mbedtls_md_setup(&ctx, mbedtls_md_info_from_type(md_type), 1); mbedtls_md_setup(&ctx, mbedtls_md_info_from_type(md_type), 1);
mbedtls_md_hmac_starts(&ctx, (unsigned char*)_secret.c_str(), _secret.length()); mbedtls_md_hmac_starts(&ctx, (unsigned char *)_secret.c_str(), _secret.length());
mbedtls_md_hmac_update(&ctx, (unsigned char*)payload.c_str(), payload.length()); mbedtls_md_hmac_update(&ctx, (unsigned char *)payload.c_str(), payload.length());
mbedtls_md_hmac_finish(&ctx, hmacResult); mbedtls_md_hmac_finish(&ctx, hmacResult);
mbedtls_md_free(&ctx); mbedtls_md_free(&ctx);
#elif defined(ESP8266) #elif defined(ESP8266)
@@ -39,10 +40,10 @@ String ArduinoJsonJWT::sign(String& payload) {
br_hmac_out(&hmacCtx, hmacResult); br_hmac_out(&hmacCtx, hmacResult);
#endif #endif
} }
return encode((char*)hmacResult, 32); return encode((char *)hmacResult, 32);
} }
String ArduinoJsonJWT::buildJWT(JsonObject& payload) { String ArduinoJsonJWT::buildJWT(JsonObject & payload) {
// serialize, then encode payload // serialize, then encode payload
String jwt; String jwt;
serializeJson(payload, jwt); serializeJson(payload, jwt);
@@ -57,7 +58,7 @@ String ArduinoJsonJWT::buildJWT(JsonObject& payload) {
return jwt; return jwt;
} }
void ArduinoJsonJWT::parseJWT(String jwt, JsonDocument& jsonDocument) { void ArduinoJsonJWT::parseJWT(String jwt, JsonDocument & jsonDocument) {
// clear json document before we begin, jsonDocument wil be null on failure // clear json document before we begin, jsonDocument wil be null on failure
jsonDocument.clear(); jsonDocument.clear();
@@ -90,7 +91,7 @@ void ArduinoJsonJWT::parseJWT(String jwt, JsonDocument& jsonDocument) {
} }
} }
String ArduinoJsonJWT::encode(const char* cstr, int inputLen) { String ArduinoJsonJWT::encode(const char * cstr, int inputLen) {
// prepare encoder // prepare encoder
base64_encodestate _state; base64_encodestate _state;
#ifdef ESP32 #ifdef ESP32
@@ -101,7 +102,7 @@ String ArduinoJsonJWT::encode(const char* cstr, int inputLen) {
size_t encodedLength = base64_encode_expected_len_nonewlines(inputLen) + 1; size_t encodedLength = base64_encode_expected_len_nonewlines(inputLen) + 1;
#endif #endif
// prepare buffer of correct length, returning an empty string on failure // prepare buffer of correct length, returning an empty string on failure
char* buffer = (char*)malloc(encodedLength * sizeof(char)); char * buffer = (char *)malloc(encodedLength * sizeof(char));
if (buffer == nullptr) { if (buffer == nullptr) {
return ""; return "";
} }

8
lib/framework/ArduinoJsonJWT.h
View File

@@ -19,9 +19,9 @@ class ArduinoJsonJWT {
const String JWT_HEADER = "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9"; const String JWT_HEADER = "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9";
const int JWT_HEADER_SIZE = JWT_HEADER.length(); const int JWT_HEADER_SIZE = JWT_HEADER.length();
String sign(String& value); String sign(String & value);
static String encode(const char* cstr, int len); static String encode(const char * cstr, int len);
static String decode(String value); static String decode(String value);
public: public:
@@ -30,8 +30,8 @@ class ArduinoJsonJWT {
void setSecret(String secret); void setSecret(String secret);
String getSecret(); String getSecret();
String buildJWT(JsonObject& payload); String buildJWT(JsonObject & payload);
void parseJWT(String jwt, JsonDocument& jsonDocument); void parseJWT(String jwt, JsonDocument & jsonDocument);
}; };
#endif #endif

21
lib/framework/AuthenticationService.cpp
View File

@@ -2,13 +2,10 @@
#if FT_ENABLED(FT_SECURITY) #if FT_ENABLED(FT_SECURITY)
AuthenticationService::AuthenticationService(AsyncWebServer* server, SecurityManager* securityManager) : AuthenticationService::AuthenticationService(AsyncWebServer * server, SecurityManager * securityManager)
_securityManager(securityManager), : _securityManager(securityManager)
_signInHandler(SIGN_IN_PATH, , _signInHandler(SIGN_IN_PATH, std::bind(&AuthenticationService::signIn, this, std::placeholders::_1, std::placeholders::_2)) {
std::bind(&AuthenticationService::signIn, this, std::placeholders::_1, std::placeholders::_2)) { server->on(VERIFY_AUTHORIZATION_PATH, HTTP_GET, std::bind(&AuthenticationService::verifyAuthorization, this, std::placeholders::_1));
server->on(VERIFY_AUTHORIZATION_PATH,
HTTP_GET,
std::bind(&AuthenticationService::verifyAuthorization, this, std::placeholders::_1));
_signInHandler.setMethod(HTTP_POST); _signInHandler.setMethod(HTTP_POST);
_signInHandler.setMaxContentLength(MAX_AUTHENTICATION_SIZE); _signInHandler.setMaxContentLength(MAX_AUTHENTICATION_SIZE);
server->addHandler(&_signInHandler); server->addHandler(&_signInHandler);
@@ -17,7 +14,7 @@ AuthenticationService::AuthenticationService(AsyncWebServer* server, SecurityMan
/** /**
* Verifys that the request supplied a valid JWT. * Verifys that the request supplied a valid JWT.
*/ */
void AuthenticationService::verifyAuthorization(AsyncWebServerRequest* request) { void AuthenticationService::verifyAuthorization(AsyncWebServerRequest * request) {
Authentication authentication = _securityManager->authenticateRequest(request); Authentication authentication = _securityManager->authenticateRequest(request);
request->send(authentication.authenticated ? 200 : 401); request->send(authentication.authenticated ? 200 : 401);
} }
@@ -26,14 +23,14 @@ void AuthenticationService::verifyAuthorization(AsyncWebServerRequest* request)
* Signs in a user if the username and password match. Provides a JWT to be used in the Authorization header in * Signs in a user if the username and password match. Provides a JWT to be used in the Authorization header in
* subsequent requests. * subsequent requests.
*/ */
void AuthenticationService::signIn(AsyncWebServerRequest* request, JsonVariant& json) { void AuthenticationService::signIn(AsyncWebServerRequest * request, JsonVariant & json) {
if (json.is<JsonObject>()) { if (json.is<JsonObject>()) {
String username = json["username"]; String username = json["username"];
String password = json["password"]; String password = json["password"];
Authentication authentication = _securityManager->authenticate(username, password); Authentication authentication = _securityManager->authenticate(username, password);
if (authentication.authenticated) { if (authentication.authenticated) {
User* user = authentication.user; User * user = authentication.user;
AsyncJsonResponse* response = new AsyncJsonResponse(false, MAX_AUTHENTICATION_SIZE); AsyncJsonResponse * response = new AsyncJsonResponse(false, MAX_AUTHENTICATION_SIZE);
JsonObject jsonObject = response->getRoot(); JsonObject jsonObject = response->getRoot();
jsonObject["access_token"] = _securityManager->generateJWT(user); jsonObject["access_token"] = _securityManager->generateJWT(user);
response->setLength(); response->setLength();
@@ -41,7 +38,7 @@ void AuthenticationService::signIn(AsyncWebServerRequest* request, JsonVariant&
return; return;
} }
} }
AsyncWebServerResponse* response = request->beginResponse(401); AsyncWebServerResponse * response = request->beginResponse(401);
request->send(response); request->send(response);
} }

8
lib/framework/AuthenticationService.h
View File

@@ -15,15 +15,15 @@
class AuthenticationService { class AuthenticationService {
public: public:
AuthenticationService(AsyncWebServer* server, SecurityManager* securityManager); AuthenticationService(AsyncWebServer * server, SecurityManager * securityManager);
private: private:
SecurityManager* _securityManager; SecurityManager * _securityManager;
AsyncCallbackJsonWebHandler _signInHandler; AsyncCallbackJsonWebHandler _signInHandler;
// endpoint functions // endpoint functions
void signIn(AsyncWebServerRequest* request, JsonVariant& json); void signIn(AsyncWebServerRequest * request, JsonVariant & json);
void verifyAuthorization(AsyncWebServerRequest* request); void verifyAuthorization(AsyncWebServerRequest * request);
}; };
#endif // end FT_ENABLED(FT_SECURITY) #endif // end FT_ENABLED(FT_SECURITY)

18
lib/framework/ESP8266React.h
View File

@@ -35,47 +35,47 @@
class ESP8266React { class ESP8266React {
public: public:
ESP8266React(AsyncWebServer* server, FS* fs); ESP8266React(AsyncWebServer * server, FS * fs);
void begin(); void begin();
void loop(); void loop();
SecurityManager* getSecurityManager() { SecurityManager * getSecurityManager() {
return &_securitySettingsService; return &_securitySettingsService;
} }
#if FT_ENABLED(FT_SECURITY) #if FT_ENABLED(FT_SECURITY)
StatefulService<SecuritySettings>* getSecuritySettingsService() { StatefulService<SecuritySettings> * getSecuritySettingsService() {
return &_securitySettingsService; return &_securitySettingsService;
} }
#endif #endif
StatefulService<WiFiSettings>* getWiFiSettingsService() { StatefulService<WiFiSettings> * getWiFiSettingsService() {
return &_wifiSettingsService; return &_wifiSettingsService;
} }
StatefulService<APSettings>* getAPSettingsService() { StatefulService<APSettings> * getAPSettingsService() {
return &_apSettingsService; return &_apSettingsService;
} }
#if FT_ENABLED(FT_NTP) #if FT_ENABLED(FT_NTP)
StatefulService<NTPSettings>* getNTPSettingsService() { StatefulService<NTPSettings> * getNTPSettingsService() {
return &_ntpSettingsService; return &_ntpSettingsService;
} }
#endif #endif
#if FT_ENABLED(FT_OTA) #if FT_ENABLED(FT_OTA)
StatefulService<OTASettings>* getOTASettingsService() { StatefulService<OTASettings> * getOTASettingsService() {
return &_otaSettingsService; return &_otaSettingsService;
} }
#endif #endif
#if FT_ENABLED(FT_MQTT) #if FT_ENABLED(FT_MQTT)
StatefulService<MqttSettings>* getMqttSettingsService() { StatefulService<MqttSettings> * getMqttSettingsService() {
return &_mqttSettingsService; return &_mqttSettingsService;
} }
AsyncMqttClient* getMqttClient() { AsyncMqttClient * getMqttClient() {
return _mqttSettingsService.getMqttClient(); return _mqttSettingsService.getMqttClient();
} }
#endif #endif

4
lib/framework/FSPersistence.h
View File

@@ -11,7 +11,7 @@ class FSPersistence {
JsonStateUpdater<T> stateUpdater, JsonStateUpdater<T> stateUpdater,
StatefulService<T> * statefulService, StatefulService<T> * statefulService,
FS * fs, FS * fs,
char const * filePath, const char * filePath,
size_t bufferSize = DEFAULT_BUFFER_SIZE) size_t bufferSize = DEFAULT_BUFFER_SIZE)
: _stateReader(stateReader) : _stateReader(stateReader)
, _stateUpdater(stateUpdater) , _stateUpdater(stateUpdater)
@@ -97,7 +97,7 @@ class FSPersistence {
JsonStateUpdater<T> _stateUpdater; JsonStateUpdater<T> _stateUpdater;
StatefulService<T> * _statefulService; StatefulService<T> * _statefulService;
FS * _fs; FS * _fs;
char const * _filePath; const char * _filePath;
size_t _bufferSize; size_t _bufferSize;
update_handler_id_t _updateHandlerId; update_handler_id_t _updateHandlerId;

6
lib/framework/FactoryResetService.h
View File

@@ -18,15 +18,15 @@
#define FACTORY_RESET_SERVICE_PATH "/rest/factoryReset" #define FACTORY_RESET_SERVICE_PATH "/rest/factoryReset"
class FactoryResetService { class FactoryResetService {
FS* fs; FS * fs;
public: public:
FactoryResetService(AsyncWebServer* server, FS* fs, SecurityManager* securityManager); FactoryResetService(AsyncWebServer * server, FS * fs, SecurityManager * securityManager);
void factoryReset(); void factoryReset();
private: private:
void handleRequest(AsyncWebServerRequest* request); void handleRequest(AsyncWebServerRequest * request);
}; };
#endif // end FactoryResetService_h #endif // end FactoryResetService_h

6
lib/framework/FeaturesService.cpp
View File

@@ -1,11 +1,11 @@
#include <FeaturesService.h> #include <FeaturesService.h>
FeaturesService::FeaturesService(AsyncWebServer* server) { FeaturesService::FeaturesService(AsyncWebServer * server) {
server->on(FEATURES_SERVICE_PATH, HTTP_GET, std::bind(&FeaturesService::features, this, std::placeholders::_1)); server->on(FEATURES_SERVICE_PATH, HTTP_GET, std::bind(&FeaturesService::features, this, std::placeholders::_1));
} }
void FeaturesService::features(AsyncWebServerRequest* request) { void FeaturesService::features(AsyncWebServerRequest * request) {
AsyncJsonResponse* response = new AsyncJsonResponse(false, MAX_FEATURES_SIZE); AsyncJsonResponse * response = new AsyncJsonResponse(false, MAX_FEATURES_SIZE);
JsonObject root = response->getRoot(); JsonObject root = response->getRoot();
#if FT_ENABLED(FT_PROJECT) #if FT_ENABLED(FT_PROJECT)
root["project"] = true; root["project"] = true;

4
lib/framework/FeaturesService.h
View File

@@ -20,10 +20,10 @@
class FeaturesService { class FeaturesService {
public: public:
FeaturesService(AsyncWebServer* server); FeaturesService(AsyncWebServer * server);
private: private:
void features(AsyncWebServerRequest* request); void features(AsyncWebServerRequest * request);
}; };
#endif #endif

126
lib/framework/HttpEndpoint.h
View File

@@ -15,35 +15,38 @@ template <class T>
class HttpGetEndpoint { class HttpGetEndpoint {
public: public:
HttpGetEndpoint(JsonStateReader<T> stateReader, HttpGetEndpoint(JsonStateReader<T> stateReader,
StatefulService<T>* statefulService, StatefulService<T> * statefulService,
AsyncWebServer* server, AsyncWebServer * server,
const String& servicePath, const String & servicePath,
SecurityManager* securityManager, SecurityManager * securityManager,
AuthenticationPredicate authenticationPredicate = AuthenticationPredicates::IS_ADMIN, AuthenticationPredicate authenticationPredicate = AuthenticationPredicates::IS_ADMIN,
size_t bufferSize = DEFAULT_BUFFER_SIZE) : size_t bufferSize = DEFAULT_BUFFER_SIZE)
_stateReader(stateReader), _statefulService(statefulService), _bufferSize(bufferSize) { : _stateReader(stateReader)
, _statefulService(statefulService)
, _bufferSize(bufferSize) {
server->on(servicePath.c_str(), server->on(servicePath.c_str(),
HTTP_GET, HTTP_GET,
securityManager->wrapRequest(std::bind(&HttpGetEndpoint::fetchSettings, this, std::placeholders::_1), securityManager->wrapRequest(std::bind(&HttpGetEndpoint::fetchSettings, this, std::placeholders::_1), authenticationPredicate));
authenticationPredicate));
} }
HttpGetEndpoint(JsonStateReader<T> stateReader, HttpGetEndpoint(JsonStateReader<T> stateReader,
StatefulService<T>* statefulService, StatefulService<T> * statefulService,
AsyncWebServer* server, AsyncWebServer * server,
const String& servicePath, const String & servicePath,
size_t bufferSize = DEFAULT_BUFFER_SIZE) : size_t bufferSize = DEFAULT_BUFFER_SIZE)
_stateReader(stateReader), _statefulService(statefulService), _bufferSize(bufferSize) { : _stateReader(stateReader)
, _statefulService(statefulService)
, _bufferSize(bufferSize) {
server->on(servicePath.c_str(), HTTP_GET, std::bind(&HttpGetEndpoint::fetchSettings, this, std::placeholders::_1)); server->on(servicePath.c_str(), HTTP_GET, std::bind(&HttpGetEndpoint::fetchSettings, this, std::placeholders::_1));
} }
protected: protected:
JsonStateReader<T> _stateReader; JsonStateReader<T> _stateReader;
StatefulService<T>* _statefulService; StatefulService<T> * _statefulService;
size_t _bufferSize; size_t _bufferSize;
void fetchSettings(AsyncWebServerRequest* request) { void fetchSettings(AsyncWebServerRequest * request) {
AsyncJsonResponse* response = new AsyncJsonResponse(false, _bufferSize); AsyncJsonResponse * response = new AsyncJsonResponse(false, _bufferSize);
JsonObject jsonObject = response->getRoot().to<JsonObject>(); JsonObject jsonObject = response->getRoot().to<JsonObject>();
_statefulService->read(jsonObject, _stateReader); _statefulService->read(jsonObject, _stateReader);
@@ -57,39 +60,35 @@ class HttpPostEndpoint {
public: public:
HttpPostEndpoint(JsonStateReader<T> stateReader, HttpPostEndpoint(JsonStateReader<T> stateReader,
JsonStateUpdater<T> stateUpdater, JsonStateUpdater<T> stateUpdater,
StatefulService<T>* statefulService, StatefulService<T> * statefulService,
AsyncWebServer* server, AsyncWebServer * server,
const String& servicePath, const String & servicePath,
SecurityManager* securityManager, SecurityManager * securityManager,
AuthenticationPredicate authenticationPredicate = AuthenticationPredicates::IS_ADMIN, AuthenticationPredicate authenticationPredicate = AuthenticationPredicates::IS_ADMIN,
size_t bufferSize = DEFAULT_BUFFER_SIZE) : size_t bufferSize = DEFAULT_BUFFER_SIZE)
_stateReader(stateReader), : _stateReader(stateReader)
_stateUpdater(stateUpdater), , _stateUpdater(stateUpdater)
_statefulService(statefulService), , _statefulService(statefulService)
_updateHandler( , _updateHandler(servicePath,
servicePath, securityManager->wrapCallback(std::bind(&HttpPostEndpoint::updateSettings, this, std::placeholders::_1, std::placeholders::_2),
securityManager->wrapCallback(
std::bind(&HttpPostEndpoint::updateSettings, this, std::placeholders::_1, std::placeholders::_2),
authenticationPredicate), authenticationPredicate),
bufferSize), bufferSize)
_bufferSize(bufferSize) { , _bufferSize(bufferSize) {
_updateHandler.setMethod(HTTP_POST); _updateHandler.setMethod(HTTP_POST);
server->addHandler(&_updateHandler); server->addHandler(&_updateHandler);
} }
HttpPostEndpoint(JsonStateReader<T> stateReader, HttpPostEndpoint(JsonStateReader<T> stateReader,
JsonStateUpdater<T> stateUpdater, JsonStateUpdater<T> stateUpdater,
StatefulService<T>* statefulService, StatefulService<T> * statefulService,
AsyncWebServer* server, AsyncWebServer * server,
const String& servicePath, const String & servicePath,
size_t bufferSize = DEFAULT_BUFFER_SIZE) : size_t bufferSize = DEFAULT_BUFFER_SIZE)
_stateReader(stateReader), : _stateReader(stateReader)
_stateUpdater(stateUpdater), , _stateUpdater(stateUpdater)
_statefulService(statefulService), , _statefulService(statefulService)
_updateHandler(servicePath, , _updateHandler(servicePath, std::bind(&HttpPostEndpoint::updateSettings, this, std::placeholders::_1, std::placeholders::_2), bufferSize)
std::bind(&HttpPostEndpoint::updateSettings, this, std::placeholders::_1, std::placeholders::_2), , _bufferSize(bufferSize) {
bufferSize),
_bufferSize(bufferSize) {
_updateHandler.setMethod(HTTP_POST); _updateHandler.setMethod(HTTP_POST);
server->addHandler(&_updateHandler); server->addHandler(&_updateHandler);
} }
@@ -97,11 +96,11 @@ class HttpPostEndpoint {
protected: protected:
JsonStateReader<T> _stateReader; JsonStateReader<T> _stateReader;
JsonStateUpdater<T> _stateUpdater; JsonStateUpdater<T> _stateUpdater;
StatefulService<T>* _statefulService; StatefulService<T> * _statefulService;
AsyncCallbackJsonWebHandler _updateHandler; AsyncCallbackJsonWebHandler _updateHandler;
size_t _bufferSize; size_t _bufferSize;
void updateSettings(AsyncWebServerRequest* request, JsonVariant& json) { void updateSettings(AsyncWebServerRequest * request, JsonVariant & json) {
if (!json.is<JsonObject>()) { if (!json.is<JsonObject>()) {
request->send(400); request->send(400);
return; return;
@@ -115,7 +114,7 @@ class HttpPostEndpoint {
if (outcome == StateUpdateResult::CHANGED) { if (outcome == StateUpdateResult::CHANGED) {
request->onDisconnect([this]() { _statefulService->callUpdateHandlers(HTTP_ENDPOINT_ORIGIN_ID); }); request->onDisconnect([this]() { _statefulService->callUpdateHandlers(HTTP_ENDPOINT_ORIGIN_ID); });
} }
AsyncJsonResponse* response = new AsyncJsonResponse(false, _bufferSize); AsyncJsonResponse * response = new AsyncJsonResponse(false, _bufferSize);
jsonObject = response->getRoot().to<JsonObject>(); jsonObject = response->getRoot().to<JsonObject>();
_statefulService->read(jsonObject, _stateReader); _statefulService->read(jsonObject, _stateReader);
response->setLength(); response->setLength();
@@ -128,37 +127,24 @@ class HttpEndpoint : public HttpGetEndpoint<T>, public HttpPostEndpoint<T> {
public: public:
HttpEndpoint(JsonStateReader<T> stateReader, HttpEndpoint(JsonStateReader<T> stateReader,
JsonStateUpdater<T> stateUpdater, JsonStateUpdater<T> stateUpdater,
StatefulService<T>* statefulService, StatefulService<T> * statefulService,
AsyncWebServer* server, AsyncWebServer * server,
const String& servicePath, const String & servicePath,
SecurityManager* securityManager, SecurityManager * securityManager,
AuthenticationPredicate authenticationPredicate = AuthenticationPredicates::IS_ADMIN, AuthenticationPredicate authenticationPredicate = AuthenticationPredicates::IS_ADMIN,
size_t bufferSize = DEFAULT_BUFFER_SIZE) : size_t bufferSize = DEFAULT_BUFFER_SIZE)
HttpGetEndpoint<T>(stateReader, : HttpGetEndpoint<T>(stateReader, statefulService, server, servicePath, securityManager, authenticationPredicate, bufferSize)
statefulService, , HttpPostEndpoint<T>(stateReader, stateUpdater, statefulService, server, servicePath, securityManager, authenticationPredicate, bufferSize) {
server,
servicePath,
securityManager,
authenticationPredicate,
bufferSize),
HttpPostEndpoint<T>(stateReader,
stateUpdater,
statefulService,
server,
servicePath,
securityManager,
authenticationPredicate,
bufferSize) {
} }
HttpEndpoint(JsonStateReader<T> stateReader, HttpEndpoint(JsonStateReader<T> stateReader,
JsonStateUpdater<T> stateUpdater, JsonStateUpdater<T> stateUpdater,
StatefulService<T>* statefulService, StatefulService<T> * statefulService,
AsyncWebServer* server, AsyncWebServer * server,
const String& servicePath, const String & servicePath,
size_t bufferSize = DEFAULT_BUFFER_SIZE) : size_t bufferSize = DEFAULT_BUFFER_SIZE)
HttpGetEndpoint<T>(stateReader, statefulService, server, servicePath, bufferSize), : HttpGetEndpoint<T>(stateReader, statefulService, server, servicePath, bufferSize)
HttpPostEndpoint<T>(stateReader, stateUpdater, statefulService, server, servicePath, bufferSize) { , HttpPostEndpoint<T>(stateReader, stateUpdater, statefulService, server, servicePath, bufferSize) {
} }
}; };

6
lib/framework/JsonUtils.h
View File

@@ -7,19 +7,19 @@
class JsonUtils { class JsonUtils {
public: public:
static void readIP(JsonObject& root, const String& key, IPAddress& ip, const String& def) { static void readIP(JsonObject & root, const String & key, IPAddress & ip, const String & def) {
IPAddress defaultIp = {}; IPAddress defaultIp = {};
if (!defaultIp.fromString(def)) { if (!defaultIp.fromString(def)) {
defaultIp = INADDR_NONE; defaultIp = INADDR_NONE;
} }
readIP(root, key, ip, defaultIp); readIP(root, key, ip, defaultIp);
} }
static void readIP(JsonObject& root, const String& key, IPAddress& ip, const IPAddress& defaultIp = INADDR_NONE) { static void readIP(JsonObject & root, const String & key, IPAddress & ip, const IPAddress & defaultIp = INADDR_NONE) {
if (!root[key].is<String>() || !ip.fromString(root[key].as<String>())) { if (!root[key].is<String>() || !ip.fromString(root[key].as<String>())) {
ip = defaultIp; ip = defaultIp;
} }
} }
static void writeIP(JsonObject& root, const String& key, const IPAddress& ip) { static void writeIP(JsonObject & root, const String & key, const IPAddress & ip) {
if (ip != INADDR_NONE) { if (ip != INADDR_NONE) {
root[key] = ip.toString(); root[key] = ip.toString();
} }

67
lib/framework/MqttPubSub.h
View File

@@ -9,19 +9,21 @@
template <class T> template <class T>
class MqttConnector { class MqttConnector {
protected: protected:
StatefulService<T>* _statefulService; StatefulService<T> * _statefulService;
AsyncMqttClient* _mqttClient; AsyncMqttClient * _mqttClient;
size_t _bufferSize; size_t _bufferSize;
MqttConnector(StatefulService<T>* statefulService, AsyncMqttClient* mqttClient, size_t bufferSize) : MqttConnector(StatefulService<T> * statefulService, AsyncMqttClient * mqttClient, size_t bufferSize)
_statefulService(statefulService), _mqttClient(mqttClient), _bufferSize(bufferSize) { : _statefulService(statefulService)
, _mqttClient(mqttClient)
, _bufferSize(bufferSize) {
_mqttClient->onConnect(std::bind(&MqttConnector::onConnect, this)); _mqttClient->onConnect(std::bind(&MqttConnector::onConnect, this));
} }
virtual void onConnect() = 0; virtual void onConnect() = 0;
public: public:
inline AsyncMqttClient* getMqttClient() const { inline AsyncMqttClient * getMqttClient() const {
return _mqttClient; return _mqttClient;
} }
}; };
@@ -30,15 +32,17 @@ template <class T>
class MqttPub : virtual public MqttConnector<T> { class MqttPub : virtual public MqttConnector<T> {
public: public:
MqttPub(JsonStateReader<T> stateReader, MqttPub(JsonStateReader<T> stateReader,
StatefulService<T>* statefulService, StatefulService<T> * statefulService,
AsyncMqttClient* mqttClient, AsyncMqttClient * mqttClient,
const String& pubTopic = "", const String & pubTopic = "",
size_t bufferSize = DEFAULT_BUFFER_SIZE) : size_t bufferSize = DEFAULT_BUFFER_SIZE)
MqttConnector<T>(statefulService, mqttClient, bufferSize), _stateReader(stateReader), _pubTopic(pubTopic) { : MqttConnector<T>(statefulService, mqttClient, bufferSize)
MqttConnector<T>::_statefulService->addUpdateHandler([&](const String& originId) { publish(); }, false); , _stateReader(stateReader)
, _pubTopic(pubTopic) {
MqttConnector<T>::_statefulService->addUpdateHandler([&](const String & originId) { publish(); }, false);
} }
void setPubTopic(const String& pubTopic) { void setPubTopic(const String & pubTopic) {
_pubTopic = pubTopic; _pubTopic = pubTopic;
publish(); publish();
} }
@@ -73,11 +77,13 @@ template <class T>
class MqttSub : virtual public MqttConnector<T> { class MqttSub : virtual public MqttConnector<T> {
public: public:
MqttSub(JsonStateUpdater<T> stateUpdater, MqttSub(JsonStateUpdater<T> stateUpdater,
StatefulService<T>* statefulService, StatefulService<T> * statefulService,
AsyncMqttClient* mqttClient, AsyncMqttClient * mqttClient,
const String& subTopic = "", const String & subTopic = "",
size_t bufferSize = DEFAULT_BUFFER_SIZE) : size_t bufferSize = DEFAULT_BUFFER_SIZE)
MqttConnector<T>(statefulService, mqttClient, bufferSize), _stateUpdater(stateUpdater), _subTopic(subTopic) { : MqttConnector<T>(statefulService, mqttClient, bufferSize)
, _stateUpdater(stateUpdater)
, _subTopic(subTopic) {
MqttConnector<T>::_mqttClient->onMessage(std::bind(&MqttSub::onMqttMessage, MqttConnector<T>::_mqttClient->onMessage(std::bind(&MqttSub::onMqttMessage,
this, this,
std::placeholders::_1, std::placeholders::_1,
@@ -88,7 +94,7 @@ class MqttSub : virtual public MqttConnector<T> {
std::placeholders::_6)); std::placeholders::_6));
} }
void setSubTopic(const String& subTopic) { void setSubTopic(const String & subTopic) {
if (!_subTopic.equals(subTopic)) { if (!_subTopic.equals(subTopic)) {
// unsubscribe from the existing topic if one was set // unsubscribe from the existing topic if one was set
if (_subTopic.length() > 0) { if (_subTopic.length() > 0) {
@@ -115,12 +121,7 @@ class MqttSub : virtual public MqttConnector<T> {
} }
} }
void onMqttMessage(char* topic, void onMqttMessage(char * topic, char * payload, AsyncMqttClientMessageProperties properties, size_t len, size_t index, size_t total) {
char* payload,
AsyncMqttClientMessageProperties properties,
size_t len,
size_t index,
size_t total) {
// we only care about the topic we are watching in this class // we only care about the topic we are watching in this class
if (strcmp(_subTopic.c_str(), topic)) { if (strcmp(_subTopic.c_str(), topic)) {
return; return;
@@ -141,18 +142,18 @@ class MqttPubSub : public MqttPub<T>, public MqttSub<T> {
public: public:
MqttPubSub(JsonStateReader<T> stateReader, MqttPubSub(JsonStateReader<T> stateReader,
JsonStateUpdater<T> stateUpdater, JsonStateUpdater<T> stateUpdater,
StatefulService<T>* statefulService, StatefulService<T> * statefulService,
AsyncMqttClient* mqttClient, AsyncMqttClient * mqttClient,
const String& pubTopic = "", const String & pubTopic = "",
const String& subTopic = "", const String & subTopic = "",
size_t bufferSize = DEFAULT_BUFFER_SIZE) : size_t bufferSize = DEFAULT_BUFFER_SIZE)
MqttConnector<T>(statefulService, mqttClient, bufferSize), : MqttConnector<T>(statefulService, mqttClient, bufferSize)
MqttPub<T>(stateReader, statefulService, mqttClient, pubTopic, bufferSize), , MqttPub<T>(stateReader, statefulService, mqttClient, pubTopic, bufferSize)
MqttSub<T>(stateUpdater, statefulService, mqttClient, subTopic, bufferSize) { , MqttSub<T>(stateUpdater, statefulService, mqttClient, subTopic, bufferSize) {
} }
public: public:
void configureTopics(const String& pubTopic, const String& subTopic) { void configureTopics(const String & pubTopic, const String & subTopic) {
MqttSub<T>::setSubTopic(subTopic); MqttSub<T>::setSubTopic(subTopic);
MqttPub<T>::setPubTopic(pubTopic); MqttPub<T>::setPubTopic(pubTopic);
} }

37
lib/framework/NTPSettingsService.cpp
View File

@@ -1,28 +1,23 @@
#include <NTPSettingsService.h> #include <NTPSettingsService.h>
NTPSettingsService::NTPSettingsService(AsyncWebServer* server, FS* fs, SecurityManager* securityManager) : NTPSettingsService::NTPSettingsService(AsyncWebServer * server, FS * fs, SecurityManager * securityManager)
_httpEndpoint(NTPSettings::read, NTPSettings::update, this, server, NTP_SETTINGS_SERVICE_PATH, securityManager), : _httpEndpoint(NTPSettings::read, NTPSettings::update, this, server, NTP_SETTINGS_SERVICE_PATH, securityManager)
_fsPersistence(NTPSettings::read, NTPSettings::update, this, fs, NTP_SETTINGS_FILE), , _fsPersistence(NTPSettings::read, NTPSettings::update, this, fs, NTP_SETTINGS_FILE)
_timeHandler(TIME_PATH, , _timeHandler(TIME_PATH,
securityManager->wrapCallback( securityManager->wrapCallback(std::bind(&NTPSettingsService::configureTime, this, std::placeholders::_1, std::placeholders::_2),
std::bind(&NTPSettingsService::configureTime, this, std::placeholders::_1, std::placeholders::_2),
AuthenticationPredicates::IS_ADMIN)) { AuthenticationPredicates::IS_ADMIN)) {
_timeHandler.setMethod(HTTP_POST); _timeHandler.setMethod(HTTP_POST);
_timeHandler.setMaxContentLength(MAX_TIME_SIZE); _timeHandler.setMaxContentLength(MAX_TIME_SIZE);
server->addHandler(&_timeHandler); server->addHandler(&_timeHandler);
#ifdef ESP32 #ifdef ESP32
WiFi.onEvent( WiFi.onEvent(std::bind(&NTPSettingsService::onStationModeDisconnected, this, std::placeholders::_1, std::placeholders::_2),
std::bind(&NTPSettingsService::onStationModeDisconnected, this, std::placeholders::_1, std::placeholders::_2),
WiFiEvent_t::SYSTEM_EVENT_STA_DISCONNECTED); WiFiEvent_t::SYSTEM_EVENT_STA_DISCONNECTED);
WiFi.onEvent(std::bind(&NTPSettingsService::onStationModeGotIP, this, std::placeholders::_1, std::placeholders::_2), WiFi.onEvent(std::bind(&NTPSettingsService::onStationModeGotIP, this, std::placeholders::_1, std::placeholders::_2), WiFiEvent_t::SYSTEM_EVENT_STA_GOT_IP);
WiFiEvent_t::SYSTEM_EVENT_STA_GOT_IP);
#elif defined(ESP8266) #elif defined(ESP8266)
_onStationModeDisconnectedHandler = WiFi.onStationModeDisconnected( _onStationModeDisconnectedHandler = WiFi.onStationModeDisconnected(std::bind(&NTPSettingsService::onStationModeDisconnected, this, std::placeholders::_1));
std::bind(&NTPSettingsService::onStationModeDisconnected, this, std::placeholders::_1)); _onStationModeGotIPHandler = WiFi.onStationModeGotIP(std::bind(&NTPSettingsService::onStationModeGotIP, this, std::placeholders::_1));
_onStationModeGotIPHandler =
WiFi.onStationModeGotIP(std::bind(&NTPSettingsService::onStationModeGotIP, this, std::placeholders::_1));
#endif #endif
addUpdateHandler([&](const String& originId) { configureNTP(); }, false); addUpdateHandler([&](const String & originId) { configureNTP(); }, false);
} }
void NTPSettingsService::begin() { void NTPSettingsService::begin() {
@@ -41,12 +36,12 @@ void NTPSettingsService::onStationModeDisconnected(WiFiEvent_t event, WiFiEventI
configureNTP(); configureNTP();
} }
#elif defined(ESP8266) #elif defined(ESP8266)
void NTPSettingsService::onStationModeGotIP(const WiFiEventStationModeGotIP& event) { void NTPSettingsService::onStationModeGotIP(const WiFiEventStationModeGotIP & event) {
// Serial.println(F("Got IP address, starting NTP Synchronization")); // Serial.println(F("Got IP address, starting NTP Synchronization"));
configureNTP(); configureNTP();
} }
void NTPSettingsService::onStationModeDisconnected(const WiFiEventStationModeDisconnected& event) { void NTPSettingsService::onStationModeDisconnected(const WiFiEventStationModeDisconnected & event) {
// Serial.println(F("WiFi connection dropped, stopping NTP.")); // Serial.println(F("WiFi connection dropped, stopping NTP."));
configureNTP(); configureNTP();
} }
@@ -71,20 +66,20 @@ void NTPSettingsService::configureNTP() {
} }
} }
void NTPSettingsService::configureTime(AsyncWebServerRequest* request, JsonVariant& json) { void NTPSettingsService::configureTime(AsyncWebServerRequest * request, JsonVariant & json) {
if (!sntp_enabled() && json.is<JsonObject>()) { if (!sntp_enabled() && json.is<JsonObject>()) {
String timeUtc = json["time_utc"]; String timeUtc = json["time_utc"];
struct tm tm = {0}; struct tm tm = {0};
char* s = strptime(timeUtc.c_str(), "%Y-%m-%dT%H:%M:%SZ", &tm); char * s = strptime(timeUtc.c_str(), "%Y-%m-%dT%H:%M:%SZ", &tm);
if (s != nullptr) { if (s != nullptr) {
time_t time = mktime(&tm); time_t time = mktime(&tm);
struct timeval now = {.tv_sec = time}; struct timeval now = {.tv_sec = time};
settimeofday(&now, nullptr); settimeofday(&now, nullptr);
AsyncWebServerResponse* response = request->beginResponse(200); AsyncWebServerResponse * response = request->beginResponse(200);
request->send(response); request->send(response);
return; return;
} }
} }
AsyncWebServerResponse* response = request->beginResponse(400); AsyncWebServerResponse * response = request->beginResponse(400);
request->send(response); request->send(response);
} }

12
lib/framework/NTPSettingsService.h
View File

@@ -40,14 +40,14 @@ class NTPSettings {
String tzFormat; String tzFormat;
String server; String server;
static void read(NTPSettings& settings, JsonObject& root) { static void read(NTPSettings & settings, JsonObject & root) {
root["enabled"] = settings.enabled; root["enabled"] = settings.enabled;
root["server"] = settings.server; root["server"] = settings.server;
root["tz_label"] = settings.tzLabel; root["tz_label"] = settings.tzLabel;
root["tz_format"] = settings.tzFormat; root["tz_format"] = settings.tzFormat;
} }
static StateUpdateResult update(JsonObject& root, NTPSettings& settings) { static StateUpdateResult update(JsonObject & root, NTPSettings & settings) {
settings.enabled = root["enabled"] | FACTORY_NTP_ENABLED; settings.enabled = root["enabled"] | FACTORY_NTP_ENABLED;
settings.server = root["server"] | FACTORY_NTP_SERVER; settings.server = root["server"] | FACTORY_NTP_SERVER;
settings.tzLabel = root["tz_label"] | FACTORY_NTP_TIME_ZONE_LABEL; settings.tzLabel = root["tz_label"] | FACTORY_NTP_TIME_ZONE_LABEL;
@@ -58,7 +58,7 @@ class NTPSettings {
class NTPSettingsService : public StatefulService<NTPSettings> { class NTPSettingsService : public StatefulService<NTPSettings> {
public: public:
NTPSettingsService(AsyncWebServer* server, FS* fs, SecurityManager* securityManager); NTPSettingsService(AsyncWebServer * server, FS * fs, SecurityManager * securityManager);
void begin(); void begin();
@@ -74,11 +74,11 @@ class NTPSettingsService : public StatefulService<NTPSettings> {
WiFiEventHandler _onStationModeDisconnectedHandler; WiFiEventHandler _onStationModeDisconnectedHandler;
WiFiEventHandler _onStationModeGotIPHandler; WiFiEventHandler _onStationModeGotIPHandler;
void onStationModeGotIP(const WiFiEventStationModeGotIP& event); void onStationModeGotIP(const WiFiEventStationModeGotIP & event);
void onStationModeDisconnected(const WiFiEventStationModeDisconnected& event); void onStationModeDisconnected(const WiFiEventStationModeDisconnected & event);
#endif #endif
void configureNTP(); void configureNTP();
void configureTime(AsyncWebServerRequest* request, JsonVariant& json); void configureTime(AsyncWebServerRequest * request, JsonVariant & json);
}; };
#endif // end NTPSettingsService_h #endif // end NTPSettingsService_h

11
lib/framework/NTPStatus.cpp
View File

@@ -1,20 +1,19 @@
#include <NTPStatus.h> #include <NTPStatus.h>
NTPStatus::NTPStatus(AsyncWebServer* server, SecurityManager* securityManager) { NTPStatus::NTPStatus(AsyncWebServer * server, SecurityManager * securityManager) {
server->on(NTP_STATUS_SERVICE_PATH, server->on(NTP_STATUS_SERVICE_PATH,
HTTP_GET, HTTP_GET,
securityManager->wrapRequest(std::bind(&NTPStatus::ntpStatus, this, std::placeholders::_1), securityManager->wrapRequest(std::bind(&NTPStatus::ntpStatus, this, std::placeholders::_1), AuthenticationPredicates::IS_AUTHENTICATED));
AuthenticationPredicates::IS_AUTHENTICATED));
} }
String toISOString(tm* time, bool incOffset) { String toISOString(tm * time, bool incOffset) {
char time_string[25]; char time_string[25];
strftime(time_string, 25, incOffset ? "%FT%T%z" : "%FT%TZ", time); strftime(time_string, 25, incOffset ? "%FT%T%z" : "%FT%TZ", time);
return String(time_string); return String(time_string);
} }
void NTPStatus::ntpStatus(AsyncWebServerRequest* request) { void NTPStatus::ntpStatus(AsyncWebServerRequest * request) {
AsyncJsonResponse* response = new AsyncJsonResponse(false, MAX_NTP_STATUS_SIZE); AsyncJsonResponse * response = new AsyncJsonResponse(false, MAX_NTP_STATUS_SIZE);
JsonObject root = response->getRoot(); JsonObject root = response->getRoot();
// grab the current instant in unix seconds // grab the current instant in unix seconds

4
lib/framework/NTPStatus.h
View File

@@ -24,10 +24,10 @@
class NTPStatus { class NTPStatus {
public: public:
NTPStatus(AsyncWebServer* server, SecurityManager* securityManager); NTPStatus(AsyncWebServer * server, SecurityManager * securityManager);
private: private:
void ntpStatus(AsyncWebServerRequest* request); void ntpStatus(AsyncWebServerRequest * request);
}; };
#endif // end NTPStatus_h #endif // end NTPStatus_h

10
lib/framework/OTASettingsService.h
View File

@@ -36,13 +36,13 @@ class OTASettings {
int port; int port;
String password; String password;
static void read(OTASettings& settings, JsonObject& root) { static void read(OTASettings & settings, JsonObject & root) {
root["enabled"] = settings.enabled; root["enabled"] = settings.enabled;
root["port"] = settings.port; root["port"] = settings.port;
root["password"] = settings.password; root["password"] = settings.password;
} }
static StateUpdateResult update(JsonObject& root, OTASettings& settings) { static StateUpdateResult update(JsonObject & root, OTASettings & settings) {
settings.enabled = root["enabled"] | FACTORY_OTA_ENABLED; settings.enabled = root["enabled"] | FACTORY_OTA_ENABLED;
settings.port = root["port"] | FACTORY_OTA_PORT; settings.port = root["port"] | FACTORY_OTA_PORT;
settings.password = root["password"] | FACTORY_OTA_PASSWORD; settings.password = root["password"] | FACTORY_OTA_PASSWORD;
@@ -52,7 +52,7 @@ class OTASettings {
class OTASettingsService : public StatefulService<OTASettings> { class OTASettingsService : public StatefulService<OTASettings> {
public: public:
OTASettingsService(AsyncWebServer* server, FS* fs, SecurityManager* securityManager); OTASettingsService(AsyncWebServer * server, FS * fs, SecurityManager * securityManager);
void begin(); void begin();
void loop(); void loop();
@@ -60,14 +60,14 @@ class OTASettingsService : public StatefulService<OTASettings> {
private: private:
HttpEndpoint<OTASettings> _httpEndpoint; HttpEndpoint<OTASettings> _httpEndpoint;
FSPersistence<OTASettings> _fsPersistence; FSPersistence<OTASettings> _fsPersistence;
ArduinoOTAClass* _arduinoOTA; ArduinoOTAClass * _arduinoOTA;
void configureArduinoOTA(); void configureArduinoOTA();
#ifdef ESP32 #ifdef ESP32
void onStationModeGotIP(WiFiEvent_t event, WiFiEventInfo_t info); void onStationModeGotIP(WiFiEvent_t event, WiFiEventInfo_t info);
#elif defined(ESP8266) #elif defined(ESP8266)
WiFiEventHandler _onStationModeGotIPHandler; WiFiEventHandler _onStationModeGotIPHandler;
void onStationModeGotIP(const WiFiEventStationModeGotIP& event); void onStationModeGotIP(const WiFiEventStationModeGotIP & event);
#endif #endif
}; };

7
lib/framework/RestartService.cpp
View File

@@ -1,13 +1,12 @@
#include <RestartService.h> #include <RestartService.h>
RestartService::RestartService(AsyncWebServer* server, SecurityManager* securityManager) { RestartService::RestartService(AsyncWebServer * server, SecurityManager * securityManager) {
server->on(RESTART_SERVICE_PATH, server->on(RESTART_SERVICE_PATH,
HTTP_POST, HTTP_POST,
securityManager->wrapRequest(std::bind(&RestartService::restart, this, std::placeholders::_1), securityManager->wrapRequest(std::bind(&RestartService::restart, this, std::placeholders::_1), AuthenticationPredicates::IS_ADMIN));
AuthenticationPredicates::IS_ADMIN));
} }
void RestartService::restart(AsyncWebServerRequest* request) { void RestartService::restart(AsyncWebServerRequest * request) {
request->onDisconnect(RestartService::restartNow); request->onDisconnect(RestartService::restartNow);
request->send(200); request->send(200);
} }

4
lib/framework/RestartService.h
View File

@@ -16,7 +16,7 @@
class RestartService { class RestartService {
public: public:
RestartService(AsyncWebServer* server, SecurityManager* securityManager); RestartService(AsyncWebServer * server, SecurityManager * securityManager);
static void restartNow() { static void restartNow() {
WiFi.disconnect(true); WiFi.disconnect(true);
@@ -25,7 +25,7 @@ class RestartService {
} }
private: private:
void restart(AsyncWebServerRequest* request); void restart(AsyncWebServerRequest * request);
}; };
#endif // end RestartService_h #endif // end RestartService_h

35
lib/framework/SecurityManager.h
View File

@@ -27,36 +27,43 @@ class User {
bool admin; bool admin;
public: public:
User(String username, String password, bool admin) : username(username), password(password), admin(admin) { User(String username, String password, bool admin)
: username(username)
, password(password)
, admin(admin) {
} }
}; };
class Authentication { class Authentication {
public: public:
User* user; User * user;
boolean authenticated; boolean authenticated;
public: public:
Authentication(User& user) : user(new User(user)), authenticated(true) { Authentication(User & user)
: user(new User(user))
, authenticated(true) {
} }
Authentication() : user(nullptr), authenticated(false) { Authentication()
: user(nullptr)
, authenticated(false) {
} }
~Authentication() { ~Authentication() {
delete (user); delete (user);
} }
}; };
typedef std::function<boolean(Authentication& authentication)> AuthenticationPredicate; typedef std::function<boolean(Authentication & authentication)> AuthenticationPredicate;
class AuthenticationPredicates { class AuthenticationPredicates {
public: public:
static bool NONE_REQUIRED(Authentication& authentication) { static bool NONE_REQUIRED(Authentication & authentication) {
return true; return true;
}; };
static bool IS_AUTHENTICATED(Authentication& authentication) { static bool IS_AUTHENTICATED(Authentication & authentication) {
return authentication.authenticated; return authentication.authenticated;
}; };
static bool IS_ADMIN(Authentication& authentication) { static bool IS_ADMIN(Authentication & authentication) {
return authentication.authenticated && authentication.user->admin; return authentication.authenticated && authentication.user->admin;
}; };
}; };
@@ -67,19 +74,19 @@ class SecurityManager {
/* /*
* Authenticate, returning the user if found * Authenticate, returning the user if found
*/ */
virtual Authentication authenticate(const String& username, const String& password) = 0; virtual Authentication authenticate(const String & username, const String & password) = 0;
/* /*
* Generate a JWT for the user provided * Generate a JWT for the user provided
*/ */
virtual String generateJWT(User* user) = 0; virtual String generateJWT(User * user) = 0;
#endif #endif
/* /*
* Check the request header for the Authorization token * Check the request header for the Authorization token
*/ */
virtual Authentication authenticateRequest(AsyncWebServerRequest* request) = 0; virtual Authentication authenticateRequest(AsyncWebServerRequest * request) = 0;
/** /**
* Filter a request with the provided predicate, only returning true if the predicate matches. * Filter a request with the provided predicate, only returning true if the predicate matches.
@@ -89,14 +96,12 @@ class SecurityManager {
/** /**
* Wrap the provided request to provide validation against an AuthenticationPredicate. * Wrap the provided request to provide validation against an AuthenticationPredicate.
*/ */
virtual ArRequestHandlerFunction wrapRequest(ArRequestHandlerFunction onRequest, virtual ArRequestHandlerFunction wrapRequest(ArRequestHandlerFunction onRequest, AuthenticationPredicate predicate) = 0;
AuthenticationPredicate predicate) = 0;
/** /**
* Wrap the provided json request callback to provide validation against an AuthenticationPredicate. * Wrap the provided json request callback to provide validation against an AuthenticationPredicate.
*/ */
virtual ArJsonRequestHandlerFunction wrapCallback(ArJsonRequestHandlerFunction onRequest, virtual ArJsonRequestHandlerFunction wrapCallback(ArJsonRequestHandlerFunction onRequest, AuthenticationPredicate predicate) = 0;
AuthenticationPredicate predicate) = 0;
}; };
#endif // end SecurityManager_h #endif // end SecurityManager_h

51
lib/framework/SecuritySettingsService.cpp
View File

@@ -2,11 +2,11 @@
#if FT_ENABLED(FT_SECURITY) #if FT_ENABLED(FT_SECURITY)
SecuritySettingsService::SecuritySettingsService(AsyncWebServer* server, FS* fs) : SecuritySettingsService::SecuritySettingsService(AsyncWebServer * server, FS * fs)
_httpEndpoint(SecuritySettings::read, SecuritySettings::update, this, server, SECURITY_SETTINGS_PATH, this), : _httpEndpoint(SecuritySettings::read, SecuritySettings::update, this, server, SECURITY_SETTINGS_PATH, this)
_fsPersistence(SecuritySettings::read, SecuritySettings::update, this, fs, SECURITY_SETTINGS_FILE), , _fsPersistence(SecuritySettings::read, SecuritySettings::update, this, fs, SECURITY_SETTINGS_FILE)
_jwtHandler(FACTORY_JWT_SECRET) { , _jwtHandler(FACTORY_JWT_SECRET) {
addUpdateHandler([&](const String& originId) { configureJWTHandler(); }, false); addUpdateHandler([&](const String & originId) { configureJWTHandler(); }, false);
} }
void SecuritySettingsService::begin() { void SecuritySettingsService::begin() {
@@ -14,8 +14,8 @@ void SecuritySettingsService::begin() {
configureJWTHandler(); configureJWTHandler();
} }
Authentication SecuritySettingsService::authenticateRequest(AsyncWebServerRequest* request) { Authentication SecuritySettingsService::authenticateRequest(AsyncWebServerRequest * request) {
AsyncWebHeader* authorizationHeader = request->getHeader(AUTHORIZATION_HEADER); AsyncWebHeader * authorizationHeader = request->getHeader(AUTHORIZATION_HEADER);
if (authorizationHeader) { if (authorizationHeader) {
String value = authorizationHeader->value(); String value = authorizationHeader->value();
if (value.startsWith(AUTHORIZATION_HEADER_PREFIX)) { if (value.startsWith(AUTHORIZATION_HEADER_PREFIX)) {
@@ -23,7 +23,7 @@ Authentication SecuritySettingsService::authenticateRequest(AsyncWebServerReques
return authenticateJWT(value); return authenticateJWT(value);
} }
} else if (request->hasParam(ACCESS_TOKEN_PARAMATER)) { } else if (request->hasParam(ACCESS_TOKEN_PARAMATER)) {
AsyncWebParameter* tokenParamater = request->getParam(ACCESS_TOKEN_PARAMATER); AsyncWebParameter * tokenParamater = request->getParam(ACCESS_TOKEN_PARAMATER);
String value = tokenParamater->value(); String value = tokenParamater->value();
return authenticateJWT(value); return authenticateJWT(value);
} }
@@ -34,7 +34,7 @@ void SecuritySettingsService::configureJWTHandler() {
_jwtHandler.setSecret(_state.jwtSecret); _jwtHandler.setSecret(_state.jwtSecret);
} }
Authentication SecuritySettingsService::authenticateJWT(String& jwt) { Authentication SecuritySettingsService::authenticateJWT(String & jwt) {
DynamicJsonDocument payloadDocument(MAX_JWT_SIZE); DynamicJsonDocument payloadDocument(MAX_JWT_SIZE);
_jwtHandler.parseJWT(jwt, payloadDocument); _jwtHandler.parseJWT(jwt, payloadDocument);
if (payloadDocument.is<JsonObject>()) { if (payloadDocument.is<JsonObject>()) {
@@ -49,7 +49,7 @@ Authentication SecuritySettingsService::authenticateJWT(String& jwt) {
return Authentication(); return Authentication();
} }
Authentication SecuritySettingsService::authenticate(const String& username, const String& password) { Authentication SecuritySettingsService::authenticate(const String & username, const String & password) {
for (User _user : _state.users) { for (User _user : _state.users) {
if (_user.username == username && _user.password == password) { if (_user.username == username && _user.password == password) {
return Authentication(_user); return Authentication(_user);
@@ -58,20 +58,20 @@ Authentication SecuritySettingsService::authenticate(const String& username, con
return Authentication(); return Authentication();
} }
inline void populateJWTPayload(JsonObject& payload, User* user) { inline void populateJWTPayload(JsonObject & payload, User * user) {
payload["username"] = user->username; payload["username"] = user->username;
payload["admin"] = user->admin; payload["admin"] = user->admin;
payload["version"] = EMSESP_APP_VERSION; // proddy added payload["version"] = EMSESP_APP_VERSION; // proddy added
} }
boolean SecuritySettingsService::validatePayload(JsonObject& parsedPayload, User* user) { boolean SecuritySettingsService::validatePayload(JsonObject & parsedPayload, User * user) {
DynamicJsonDocument jsonDocument(MAX_JWT_SIZE); DynamicJsonDocument jsonDocument(MAX_JWT_SIZE);
JsonObject payload = jsonDocument.to<JsonObject>(); JsonObject payload = jsonDocument.to<JsonObject>();
populateJWTPayload(payload, user); populateJWTPayload(payload, user);
return payload == parsedPayload; return payload == parsedPayload;
} }
String SecuritySettingsService::generateJWT(User* user) { String SecuritySettingsService::generateJWT(User * user) {
DynamicJsonDocument jsonDocument(MAX_JWT_SIZE); DynamicJsonDocument jsonDocument(MAX_JWT_SIZE);
JsonObject payload = jsonDocument.to<JsonObject>(); JsonObject payload = jsonDocument.to<JsonObject>();
populateJWTPayload(payload, user); populateJWTPayload(payload, user);
@@ -79,15 +79,14 @@ String SecuritySettingsService::generateJWT(User* user) {
} }
ArRequestFilterFunction SecuritySettingsService::filterRequest(AuthenticationPredicate predicate) { ArRequestFilterFunction SecuritySettingsService::filterRequest(AuthenticationPredicate predicate) {
return [this, predicate](AsyncWebServerRequest* request) { return [this, predicate](AsyncWebServerRequest * request) {
Authentication authentication = authenticateRequest(request); Authentication authentication = authenticateRequest(request);
return predicate(authentication); return predicate(authentication);
}; };
} }
ArRequestHandlerFunction SecuritySettingsService::wrapRequest(ArRequestHandlerFunction onRequest, ArRequestHandlerFunction SecuritySettingsService::wrapRequest(ArRequestHandlerFunction onRequest, AuthenticationPredicate predicate) {
AuthenticationPredicate predicate) { return [this, onRequest, predicate](AsyncWebServerRequest * request) {
return [this, onRequest, predicate](AsyncWebServerRequest* request) {
Authentication authentication = authenticateRequest(request); Authentication authentication = authenticateRequest(request);
if (!predicate(authentication)) { if (!predicate(authentication)) {
request->send(401); request->send(401);
@@ -97,9 +96,8 @@ ArRequestHandlerFunction SecuritySettingsService::wrapRequest(ArRequestHandlerFu
}; };
} }
ArJsonRequestHandlerFunction SecuritySettingsService::wrapCallback(ArJsonRequestHandlerFunction onRequest, ArJsonRequestHandlerFunction SecuritySettingsService::wrapCallback(ArJsonRequestHandlerFunction onRequest, AuthenticationPredicate predicate) {
AuthenticationPredicate predicate) { return [this, onRequest, predicate](AsyncWebServerRequest * request, JsonVariant & json) {
return [this, onRequest, predicate](AsyncWebServerRequest* request, JsonVariant& json) {
Authentication authentication = authenticateRequest(request); Authentication authentication = authenticateRequest(request);
if (!predicate(authentication)) { if (!predicate(authentication)) {
request->send(401); request->send(401);
@@ -113,28 +111,27 @@ ArJsonRequestHandlerFunction SecuritySettingsService::wrapCallback(ArJsonRequest
User ADMIN_USER = User(FACTORY_ADMIN_USERNAME, FACTORY_ADMIN_PASSWORD, true); User ADMIN_USER = User(FACTORY_ADMIN_USERNAME, FACTORY_ADMIN_PASSWORD, true);
SecuritySettingsService::SecuritySettingsService(AsyncWebServer* server, FS* fs) : SecurityManager() { SecuritySettingsService::SecuritySettingsService(AsyncWebServer * server, FS * fs)
: SecurityManager() {
} }
SecuritySettingsService::~SecuritySettingsService() { SecuritySettingsService::~SecuritySettingsService() {
} }
ArRequestFilterFunction SecuritySettingsService::filterRequest(AuthenticationPredicate predicate) { ArRequestFilterFunction SecuritySettingsService::filterRequest(AuthenticationPredicate predicate) {
return [this, predicate](AsyncWebServerRequest* request) { return true; }; return [this, predicate](AsyncWebServerRequest * request) { return true; };
} }
// Return the admin user on all request - disabling security features // Return the admin user on all request - disabling security features
Authentication SecuritySettingsService::authenticateRequest(AsyncWebServerRequest* request) { Authentication SecuritySettingsService::authenticateRequest(AsyncWebServerRequest * request) {
return Authentication(ADMIN_USER); return Authentication(ADMIN_USER);
} }
// Return the function unwrapped // Return the function unwrapped
ArRequestHandlerFunction SecuritySettingsService::wrapRequest(ArRequestHandlerFunction onRequest, ArRequestHandlerFunction SecuritySettingsService::wrapRequest(ArRequestHandlerFunction onRequest, AuthenticationPredicate predicate) {
AuthenticationPredicate predicate) {
return onRequest; return onRequest;
} }
ArJsonRequestHandlerFunction SecuritySettingsService::wrapCallback(ArJsonRequestHandlerFunction onRequest, ArJsonRequestHandlerFunction SecuritySettingsService::wrapCallback(ArJsonRequestHandlerFunction onRequest, AuthenticationPredicate predicate) {
AuthenticationPredicate predicate) {
return onRequest; return onRequest;
} }

20
lib/framework/SecuritySettingsService.h
View File

@@ -34,7 +34,7 @@ class SecuritySettings {
String jwtSecret; String jwtSecret;
std::list<User> users; std::list<User> users;
static void read(SecuritySettings& settings, JsonObject& root) { static void read(SecuritySettings & settings, JsonObject & root) {
// secret // secret
root["jwt_secret"] = settings.jwtSecret; root["jwt_secret"] = settings.jwtSecret;
@@ -48,7 +48,7 @@ class SecuritySettings {
} }
} }
static StateUpdateResult update(JsonObject& root, SecuritySettings& settings) { static StateUpdateResult update(JsonObject & root, SecuritySettings & settings) {
// secret // secret
settings.jwtSecret = root["jwt_secret"] | FACTORY_JWT_SECRET; settings.jwtSecret = root["jwt_secret"] | FACTORY_JWT_SECRET;
@@ -68,14 +68,14 @@ class SecuritySettings {
class SecuritySettingsService : public StatefulService<SecuritySettings>, public SecurityManager { class SecuritySettingsService : public StatefulService<SecuritySettings>, public SecurityManager {
public: public:
SecuritySettingsService(AsyncWebServer* server, FS* fs); SecuritySettingsService(AsyncWebServer * server, FS * fs);
void begin(); void begin();
// Functions to implement SecurityManager // Functions to implement SecurityManager
Authentication authenticate(const String& username, const String& password); Authentication authenticate(const String & username, const String & password);
Authentication authenticateRequest(AsyncWebServerRequest* request); Authentication authenticateRequest(AsyncWebServerRequest * request);
String generateJWT(User* user); String generateJWT(User * user);
ArRequestFilterFunction filterRequest(AuthenticationPredicate predicate); ArRequestFilterFunction filterRequest(AuthenticationPredicate predicate);
ArRequestHandlerFunction wrapRequest(ArRequestHandlerFunction onRequest, AuthenticationPredicate predicate); ArRequestHandlerFunction wrapRequest(ArRequestHandlerFunction onRequest, AuthenticationPredicate predicate);
ArJsonRequestHandlerFunction wrapCallback(ArJsonRequestHandlerFunction callback, AuthenticationPredicate predicate); ArJsonRequestHandlerFunction wrapCallback(ArJsonRequestHandlerFunction callback, AuthenticationPredicate predicate);
@@ -90,23 +90,23 @@ class SecuritySettingsService : public StatefulService<SecuritySettings>, public
/* /*
* Lookup the user by JWT * Lookup the user by JWT
*/ */
Authentication authenticateJWT(String& jwt); Authentication authenticateJWT(String & jwt);
/* /*
* Verify the payload is correct * Verify the payload is correct
*/ */
boolean validatePayload(JsonObject& parsedPayload, User* user); boolean validatePayload(JsonObject & parsedPayload, User * user);
}; };
#else #else
class SecuritySettingsService : public SecurityManager { class SecuritySettingsService : public SecurityManager {
public: public:
SecuritySettingsService(AsyncWebServer* server, FS* fs); SecuritySettingsService(AsyncWebServer * server, FS * fs);
~SecuritySettingsService(); ~SecuritySettingsService();
// minimal set of functions to support framework with security settings disabled // minimal set of functions to support framework with security settings disabled
Authentication authenticateRequest(AsyncWebServerRequest* request); Authentication authenticateRequest(AsyncWebServerRequest * request);
ArRequestFilterFunction filterRequest(AuthenticationPredicate predicate); ArRequestFilterFunction filterRequest(AuthenticationPredicate predicate);
ArRequestHandlerFunction wrapRequest(ArRequestHandlerFunction onRequest, AuthenticationPredicate predicate); ArRequestHandlerFunction wrapRequest(ArRequestHandlerFunction onRequest, AuthenticationPredicate predicate);
ArJsonRequestHandlerFunction wrapCallback(ArJsonRequestHandlerFunction onRequest, AuthenticationPredicate predicate); ArJsonRequestHandlerFunction wrapCallback(ArJsonRequestHandlerFunction onRequest, AuthenticationPredicate predicate);

36
lib/framework/StatefulService.h
View File

@@ -22,21 +22,23 @@ enum class StateUpdateResult {
}; };
template <typename T> template <typename T>
using JsonStateUpdater = std::function<StateUpdateResult(JsonObject& root, T& settings)>; using JsonStateUpdater = std::function<StateUpdateResult(JsonObject & root, T & settings)>;
template <typename T> template <typename T>
using JsonStateReader = std::function<void(T& settings, JsonObject& root)>; using JsonStateReader = std::function<void(T & settings, JsonObject & root)>;
typedef size_t update_handler_id_t; typedef size_t update_handler_id_t;
typedef std::function<void(const String& originId)> StateUpdateCallback; typedef std::function<void(const String & originId)> StateUpdateCallback;
typedef struct StateUpdateHandlerInfo { typedef struct StateUpdateHandlerInfo {
static update_handler_id_t currentUpdatedHandlerId; static update_handler_id_t currentUpdatedHandlerId;
update_handler_id_t _id; update_handler_id_t _id;
StateUpdateCallback _cb; StateUpdateCallback _cb;
bool _allowRemove; bool _allowRemove;
StateUpdateHandlerInfo(StateUpdateCallback cb, bool allowRemove) : StateUpdateHandlerInfo(StateUpdateCallback cb, bool allowRemove)
_id(++currentUpdatedHandlerId), _cb(cb), _allowRemove(allowRemove){}; : _id(++currentUpdatedHandlerId)
, _cb(cb)
, _allowRemove(allowRemove){};
} StateUpdateHandlerInfo_t; } StateUpdateHandlerInfo_t;
template <class T> template <class T>
@@ -44,11 +46,13 @@ class StatefulService {
public: public:
template <typename... Args> template <typename... Args>
#ifdef ESP32 #ifdef ESP32
StatefulService(Args&&... args) : StatefulService(Args &&... args)
_state(std::forward<Args>(args)...), _accessMutex(xSemaphoreCreateRecursiveMutex()) { : _state(std::forward<Args>(args)...)
, _accessMutex(xSemaphoreCreateRecursiveMutex()) {
} }
#else #else
StatefulService(Args&&... args) : _state(std::forward<Args>(args)...) { StatefulService(Args &&... args)
: _state(std::forward<Args>(args)...) {
} }
#endif #endif
@@ -71,7 +75,7 @@ class StatefulService {
} }
} }
StateUpdateResult update(std::function<StateUpdateResult(T&)> stateUpdater, const String& originId) { StateUpdateResult update(std::function<StateUpdateResult(T &)> stateUpdater, const String & originId) {
beginTransaction(); beginTransaction();
StateUpdateResult result = stateUpdater(_state); StateUpdateResult result = stateUpdater(_state);
endTransaction(); endTransaction();
@@ -81,14 +85,14 @@ class StatefulService {
return result; return result;
} }
StateUpdateResult updateWithoutPropagation(std::function<StateUpdateResult(T&)> stateUpdater) { StateUpdateResult updateWithoutPropagation(std::function<StateUpdateResult(T &)> stateUpdater) {
beginTransaction(); beginTransaction();
StateUpdateResult result = stateUpdater(_state); StateUpdateResult result = stateUpdater(_state);
endTransaction(); endTransaction();
return result; return result;
} }
StateUpdateResult update(JsonObject& jsonObject, JsonStateUpdater<T> stateUpdater, const String& originId) { StateUpdateResult update(JsonObject & jsonObject, JsonStateUpdater<T> stateUpdater, const String & originId) {
beginTransaction(); beginTransaction();
StateUpdateResult result = stateUpdater(jsonObject, _state); StateUpdateResult result = stateUpdater(jsonObject, _state);
endTransaction(); endTransaction();
@@ -98,27 +102,27 @@ class StatefulService {
return result; return result;
} }
StateUpdateResult updateWithoutPropagation(JsonObject& jsonObject, JsonStateUpdater<T> stateUpdater) { StateUpdateResult updateWithoutPropagation(JsonObject & jsonObject, JsonStateUpdater<T> stateUpdater) {
beginTransaction(); beginTransaction();
StateUpdateResult result = stateUpdater(jsonObject, _state); StateUpdateResult result = stateUpdater(jsonObject, _state);
endTransaction(); endTransaction();
return result; return result;
} }
void read(std::function<void(T&)> stateReader) { void read(std::function<void(T &)> stateReader) {
beginTransaction(); beginTransaction();
stateReader(_state); stateReader(_state);
endTransaction(); endTransaction();
} }
void read(JsonObject& jsonObject, JsonStateReader<T> stateReader) { void read(JsonObject & jsonObject, JsonStateReader<T> stateReader) {
beginTransaction(); beginTransaction();
stateReader(_state, jsonObject); stateReader(_state, jsonObject);
endTransaction(); endTransaction();
} }
void callUpdateHandlers(const String& originId) { void callUpdateHandlers(const String & originId) {
for (const StateUpdateHandlerInfo_t& updateHandler : _updateHandlers) { for (const StateUpdateHandlerInfo_t & updateHandler : _updateHandlers) {
updateHandler._cb(originId); updateHandler._cb(originId);
} }
} }

19
lib/framework/UploadFirmwareService.cpp
View File

@@ -1,7 +1,7 @@
#include <UploadFirmwareService.h> #include <UploadFirmwareService.h>
UploadFirmwareService::UploadFirmwareService(AsyncWebServer* server, SecurityManager* securityManager) : UploadFirmwareService::UploadFirmwareService(AsyncWebServer * server, SecurityManager * securityManager)
_securityManager(securityManager) { : _securityManager(securityManager) {
server->on(UPLOAD_FIRMWARE_PATH, server->on(UPLOAD_FIRMWARE_PATH,
HTTP_POST, HTTP_POST,
std::bind(&UploadFirmwareService::uploadComplete, this, std::placeholders::_1), std::bind(&UploadFirmwareService::uploadComplete, this, std::placeholders::_1),
@@ -18,12 +18,7 @@ UploadFirmwareService::UploadFirmwareService(AsyncWebServer* server, SecurityMan
#endif #endif
} }
void UploadFirmwareService::handleUpload(AsyncWebServerRequest* request, void UploadFirmwareService::handleUpload(AsyncWebServerRequest * request, const String & filename, size_t index, uint8_t * data, size_t len, bool final) {
const String& filename,
size_t index,
uint8_t* data,
size_t len,
bool final) {
if (!index) { if (!index) {
Authentication authentication = _securityManager->authenticateRequest(request); Authentication authentication = _securityManager->authenticateRequest(request);
if (AuthenticationPredicates::IS_ADMIN(authentication)) { if (AuthenticationPredicates::IS_ADMIN(authentication)) {
@@ -56,23 +51,23 @@ void UploadFirmwareService::handleUpload(AsyncWebServerRequest* request,
} }
} }
void UploadFirmwareService::uploadComplete(AsyncWebServerRequest* request) { void UploadFirmwareService::uploadComplete(AsyncWebServerRequest * request) {
// if no error, send the success response // if no error, send the success response
if (!request->_tempObject) { if (!request->_tempObject) {
request->onDisconnect(RestartService::restartNow); request->onDisconnect(RestartService::restartNow);
AsyncWebServerResponse* response = request->beginResponse(200); AsyncWebServerResponse * response = request->beginResponse(200);
request->send(response); request->send(response);
} }
} }
void UploadFirmwareService::handleError(AsyncWebServerRequest* request, int code) { void UploadFirmwareService::handleError(AsyncWebServerRequest * request, int code) {
// if we have had an error already, do nothing // if we have had an error already, do nothing
if (request->_tempObject) { if (request->_tempObject) {
return; return;
} }
// send the error code to the client and record the error code in the temp object // send the error code to the client and record the error code in the temp object
request->_tempObject = new int(code); request->_tempObject = new int(code);
AsyncWebServerResponse* response = request->beginResponse(code); AsyncWebServerResponse * response = request->beginResponse(code);
request->send(response); request->send(response);
} }

15
lib/framework/UploadFirmwareService.h
View File

@@ -20,18 +20,13 @@
class UploadFirmwareService { class UploadFirmwareService {
public: public:
UploadFirmwareService(AsyncWebServer* server, SecurityManager* securityManager); UploadFirmwareService(AsyncWebServer * server, SecurityManager * securityManager);
private: private:
SecurityManager* _securityManager; SecurityManager * _securityManager;
void handleUpload(AsyncWebServerRequest* request, void handleUpload(AsyncWebServerRequest * request, const String & filename, size_t index, uint8_t * data, size_t len, bool final);
const String& filename, void uploadComplete(AsyncWebServerRequest * request);
size_t index, void handleError(AsyncWebServerRequest * request, int code);
uint8_t* data,
size_t len,
bool final);
void uploadComplete(AsyncWebServerRequest* request);
void handleError(AsyncWebServerRequest* request, int code);
static void handleEarlyDisconnect(); static void handleEarlyDisconnect();
}; };

193
lib/framework/WebSocketTxRx.h
View File

@@ -13,18 +13,21 @@
template <class T> template <class T>
class WebSocketConnector { class WebSocketConnector {
protected: protected:
StatefulService<T>* _statefulService; StatefulService<T> * _statefulService;
AsyncWebServer* _server; AsyncWebServer * _server;
AsyncWebSocket _webSocket; AsyncWebSocket _webSocket;
size_t _bufferSize; size_t _bufferSize;
WebSocketConnector(StatefulService<T>* statefulService, WebSocketConnector(StatefulService<T> * statefulService,
AsyncWebServer* server, AsyncWebServer * server,
char const* webSocketPath, const char * webSocketPath,
SecurityManager* securityManager, SecurityManager * securityManager,
AuthenticationPredicate authenticationPredicate, AuthenticationPredicate authenticationPredicate,
size_t bufferSize) : size_t bufferSize)
_statefulService(statefulService), _server(server), _webSocket(webSocketPath), _bufferSize(bufferSize) { : _statefulService(statefulService)
, _server(server)
, _webSocket(webSocketPath)
, _bufferSize(bufferSize) {
_webSocket.setFilter(securityManager->filterRequest(authenticationPredicate)); _webSocket.setFilter(securityManager->filterRequest(authenticationPredicate));
_webSocket.onEvent(std::bind(&WebSocketConnector::onWSEvent, _webSocket.onEvent(std::bind(&WebSocketConnector::onWSEvent,
this, this,
@@ -38,11 +41,11 @@ class WebSocketConnector {
_server->on(webSocketPath, HTTP_GET, std::bind(&WebSocketConnector::forbidden, this, std::placeholders::_1)); _server->on(webSocketPath, HTTP_GET, std::bind(&WebSocketConnector::forbidden, this, std::placeholders::_1));
} }
WebSocketConnector(StatefulService<T>* statefulService, WebSocketConnector(StatefulService<T> * statefulService, AsyncWebServer * server, const char * webSocketPath, size_t bufferSize)
AsyncWebServer* server, : _statefulService(statefulService)
char const* webSocketPath, , _server(server)
size_t bufferSize) : , _webSocket(webSocketPath)
_statefulService(statefulService), _server(server), _webSocket(webSocketPath), _bufferSize(bufferSize) { , _bufferSize(bufferSize) {
_webSocket.onEvent(std::bind(&WebSocketConnector::onWSEvent, _webSocket.onEvent(std::bind(&WebSocketConnector::onWSEvent,
this, this,
std::placeholders::_1, std::placeholders::_1,
@@ -54,19 +57,14 @@ class WebSocketConnector {
_server->addHandler(&_webSocket); _server->addHandler(&_webSocket);
} }
virtual void onWSEvent(AsyncWebSocket* server, virtual void onWSEvent(AsyncWebSocket * server, AsyncWebSocketClient * client, AwsEventType type, void * arg, uint8_t * data, size_t len) = 0;
AsyncWebSocketClient* client,
AwsEventType type,
void* arg,
uint8_t* data,
size_t len) = 0;
String clientId(AsyncWebSocketClient* client) { String clientId(AsyncWebSocketClient * client) {
return WEB_SOCKET_ORIGIN_CLIENT_ID_PREFIX + String(client->id()); return WEB_SOCKET_ORIGIN_CLIENT_ID_PREFIX + String(client->id());
} }
private: private:
void forbidden(AsyncWebServerRequest* request) { void forbidden(AsyncWebServerRequest * request) {
request->send(403); request->send(403);
} }
}; };
@@ -75,40 +73,29 @@ template <class T>
class WebSocketTx : virtual public WebSocketConnector<T> { class WebSocketTx : virtual public WebSocketConnector<T> {
public: public:
WebSocketTx(JsonStateReader<T> stateReader, WebSocketTx(JsonStateReader<T> stateReader,
StatefulService<T>* statefulService, StatefulService<T> * statefulService,
AsyncWebServer* server, AsyncWebServer * server,
char const* webSocketPath, const char * webSocketPath,
SecurityManager* securityManager, SecurityManager * securityManager,
AuthenticationPredicate authenticationPredicate = AuthenticationPredicates::IS_ADMIN, AuthenticationPredicate authenticationPredicate = AuthenticationPredicates::IS_ADMIN,
size_t bufferSize = DEFAULT_BUFFER_SIZE) : size_t bufferSize = DEFAULT_BUFFER_SIZE)
WebSocketConnector<T>(statefulService, : WebSocketConnector<T>(statefulService, server, webSocketPath, securityManager, authenticationPredicate, bufferSize)
server, , _stateReader(stateReader) {
webSocketPath, WebSocketConnector<T>::_statefulService->addUpdateHandler([&](const String & originId) { transmitData(nullptr, originId); }, false);
securityManager,
authenticationPredicate,
bufferSize),
_stateReader(stateReader) {
WebSocketConnector<T>::_statefulService->addUpdateHandler(
[&](const String& originId) { transmitData(nullptr, originId); }, false);
} }
WebSocketTx(JsonStateReader<T> stateReader, WebSocketTx(JsonStateReader<T> stateReader,
StatefulService<T>* statefulService, StatefulService<T> * statefulService,
AsyncWebServer* server, AsyncWebServer * server,
char const* webSocketPath, const char * webSocketPath,
size_t bufferSize = DEFAULT_BUFFER_SIZE) : size_t bufferSize = DEFAULT_BUFFER_SIZE)
WebSocketConnector<T>(statefulService, server, webSocketPath, bufferSize), _stateReader(stateReader) { : WebSocketConnector<T>(statefulService, server, webSocketPath, bufferSize)
WebSocketConnector<T>::_statefulService->addUpdateHandler( , _stateReader(stateReader) {
[&](const String& originId) { transmitData(nullptr, originId); }, false); WebSocketConnector<T>::_statefulService->addUpdateHandler([&](const String & originId) { transmitData(nullptr, originId); }, false);
} }
protected: protected:
virtual void onWSEvent(AsyncWebSocket* server, virtual void onWSEvent(AsyncWebSocket * server, AsyncWebSocketClient * client, AwsEventType type, void * arg, uint8_t * data, size_t len) {
AsyncWebSocketClient* client,
AwsEventType type,
void* arg,
uint8_t* data,
size_t len) {
if (type == WS_EVT_CONNECT) { if (type == WS_EVT_CONNECT) {
// when a client connects, we transmit it's id and the current payload // when a client connects, we transmit it's id and the current payload
transmitId(client); transmitId(client);
@@ -119,15 +106,15 @@ class WebSocketTx : virtual public WebSocketConnector<T> {
private: private:
JsonStateReader<T> _stateReader; JsonStateReader<T> _stateReader;
void transmitId(AsyncWebSocketClient* client) { void transmitId(AsyncWebSocketClient * client) {
DynamicJsonDocument jsonDocument = DynamicJsonDocument(WEB_SOCKET_CLIENT_ID_MSG_SIZE); DynamicJsonDocument jsonDocument = DynamicJsonDocument(WEB_SOCKET_CLIENT_ID_MSG_SIZE);
JsonObject root = jsonDocument.to<JsonObject>(); JsonObject root = jsonDocument.to<JsonObject>();
root["type"] = "id"; root["type"] = "id";
root["id"] = WebSocketConnector<T>::clientId(client); root["id"] = WebSocketConnector<T>::clientId(client);
size_t len = measureJson(jsonDocument); size_t len = measureJson(jsonDocument);
AsyncWebSocketMessageBuffer* buffer = WebSocketConnector<T>::_webSocket.makeBuffer(len); AsyncWebSocketMessageBuffer * buffer = WebSocketConnector<T>::_webSocket.makeBuffer(len);
if (buffer) { if (buffer) {
serializeJson(jsonDocument, (char*)buffer->get(), len + 1); serializeJson(jsonDocument, (char *)buffer->get(), len + 1);
client->text(buffer); client->text(buffer);
} }
} }
@@ -139,7 +126,7 @@ class WebSocketTx : virtual public WebSocketConnector<T> {
* Original implementation sent clients their own IDs so they could ignore updates they initiated. This approach * Original implementation sent clients their own IDs so they could ignore updates they initiated. This approach
* simplifies the client and the server implementation but may not be sufficent for all use-cases. * simplifies the client and the server implementation but may not be sufficent for all use-cases.
*/ */
void transmitData(AsyncWebSocketClient* client, const String& originId) { void transmitData(AsyncWebSocketClient * client, const String & originId) {
DynamicJsonDocument jsonDocument = DynamicJsonDocument(WebSocketConnector<T>::_bufferSize); DynamicJsonDocument jsonDocument = DynamicJsonDocument(WebSocketConnector<T>::_bufferSize);
JsonObject root = jsonDocument.to<JsonObject>(); JsonObject root = jsonDocument.to<JsonObject>();
root["type"] = "payload"; root["type"] = "payload";
@@ -148,9 +135,9 @@ class WebSocketTx : virtual public WebSocketConnector<T> {
WebSocketConnector<T>::_statefulService->read(payload, _stateReader); WebSocketConnector<T>::_statefulService->read(payload, _stateReader);
size_t len = measureJson(jsonDocument); size_t len = measureJson(jsonDocument);
AsyncWebSocketMessageBuffer* buffer = WebSocketConnector<T>::_webSocket.makeBuffer(len); AsyncWebSocketMessageBuffer * buffer = WebSocketConnector<T>::_webSocket.makeBuffer(len);
if (buffer) { if (buffer) {
serializeJson(jsonDocument, (char*)buffer->get(), len + 1); serializeJson(jsonDocument, (char *)buffer->get(), len + 1);
if (client) { if (client) {
client->text(buffer); client->text(buffer);
} else { } else {
@@ -164,46 +151,36 @@ template <class T>
class WebSocketRx : virtual public WebSocketConnector<T> { class WebSocketRx : virtual public WebSocketConnector<T> {
public: public:
WebSocketRx(JsonStateUpdater<T> stateUpdater, WebSocketRx(JsonStateUpdater<T> stateUpdater,
StatefulService<T>* statefulService, StatefulService<T> * statefulService,
AsyncWebServer* server, AsyncWebServer * server,
char const* webSocketPath, const char * webSocketPath,
SecurityManager* securityManager, SecurityManager * securityManager,
AuthenticationPredicate authenticationPredicate = AuthenticationPredicates::IS_ADMIN, AuthenticationPredicate authenticationPredicate = AuthenticationPredicates::IS_ADMIN,
size_t bufferSize = DEFAULT_BUFFER_SIZE) : size_t bufferSize = DEFAULT_BUFFER_SIZE)
WebSocketConnector<T>(statefulService, : WebSocketConnector<T>(statefulService, server, webSocketPath, securityManager, authenticationPredicate, bufferSize)
server, , _stateUpdater(stateUpdater) {
webSocketPath,
securityManager,
authenticationPredicate,
bufferSize),
_stateUpdater(stateUpdater) {
} }
WebSocketRx(JsonStateUpdater<T> stateUpdater, WebSocketRx(JsonStateUpdater<T> stateUpdater,
StatefulService<T>* statefulService, StatefulService<T> * statefulService,
AsyncWebServer* server, AsyncWebServer * server,
char const* webSocketPath, const char * webSocketPath,
size_t bufferSize = DEFAULT_BUFFER_SIZE) : size_t bufferSize = DEFAULT_BUFFER_SIZE)
WebSocketConnector<T>(statefulService, server, webSocketPath, bufferSize), _stateUpdater(stateUpdater) { : WebSocketConnector<T>(statefulService, server, webSocketPath, bufferSize)
, _stateUpdater(stateUpdater) {
} }
protected: protected:
virtual void onWSEvent(AsyncWebSocket* server, virtual void onWSEvent(AsyncWebSocket * server, AsyncWebSocketClient * client, AwsEventType type, void * arg, uint8_t * data, size_t len) {
AsyncWebSocketClient* client,
AwsEventType type,
void* arg,
uint8_t* data,
size_t len) {
if (type == WS_EVT_DATA) { if (type == WS_EVT_DATA) {
AwsFrameInfo* info = (AwsFrameInfo*)arg; AwsFrameInfo * info = (AwsFrameInfo *)arg;
if (info->final && info->index == 0 && info->len == len) { if (info->final && info->index == 0 && info->len == len) {
if (info->opcode == WS_TEXT) { if (info->opcode == WS_TEXT) {
DynamicJsonDocument jsonDocument = DynamicJsonDocument(WebSocketConnector<T>::_bufferSize); DynamicJsonDocument jsonDocument = DynamicJsonDocument(WebSocketConnector<T>::_bufferSize);
DeserializationError error = deserializeJson(jsonDocument, (char*)data); DeserializationError error = deserializeJson(jsonDocument, (char *)data);
if (!error && jsonDocument.is<JsonObject>()) { if (!error && jsonDocument.is<JsonObject>()) {
JsonObject jsonObject = jsonDocument.as<JsonObject>(); JsonObject jsonObject = jsonDocument.as<JsonObject>();
WebSocketConnector<T>::_statefulService->update( WebSocketConnector<T>::_statefulService->update(jsonObject, _stateUpdater, WebSocketConnector<T>::clientId(client));
jsonObject, _stateUpdater, WebSocketConnector<T>::clientId(client));
} }
} }
} }
@@ -219,52 +196,30 @@ class WebSocketTxRx : public WebSocketTx<T>, public WebSocketRx<T> {
public: public:
WebSocketTxRx(JsonStateReader<T> stateReader, WebSocketTxRx(JsonStateReader<T> stateReader,
JsonStateUpdater<T> stateUpdater, JsonStateUpdater<T> stateUpdater,
StatefulService<T>* statefulService, StatefulService<T> * statefulService,
AsyncWebServer* server, AsyncWebServer * server,
char const* webSocketPath, const char * webSocketPath,
SecurityManager* securityManager, SecurityManager * securityManager,
AuthenticationPredicate authenticationPredicate = AuthenticationPredicates::IS_ADMIN, AuthenticationPredicate authenticationPredicate = AuthenticationPredicates::IS_ADMIN,
size_t bufferSize = DEFAULT_BUFFER_SIZE) : size_t bufferSize = DEFAULT_BUFFER_SIZE)
WebSocketConnector<T>(statefulService, : WebSocketConnector<T>(statefulService, server, webSocketPath, securityManager, authenticationPredicate, bufferSize)
server, , WebSocketTx<T>(stateReader, statefulService, server, webSocketPath, securityManager, authenticationPredicate, bufferSize)
webSocketPath, , WebSocketRx<T>(stateUpdater, statefulService, server, webSocketPath, securityManager, authenticationPredicate, bufferSize) {
securityManager,
authenticationPredicate,
bufferSize),
WebSocketTx<T>(stateReader,
statefulService,
server,
webSocketPath,
securityManager,
authenticationPredicate,
bufferSize),
WebSocketRx<T>(stateUpdater,
statefulService,
server,
webSocketPath,
securityManager,
authenticationPredicate,
bufferSize) {
} }
WebSocketTxRx(JsonStateReader<T> stateReader, WebSocketTxRx(JsonStateReader<T> stateReader,
JsonStateUpdater<T> stateUpdater, JsonStateUpdater<T> stateUpdater,
StatefulService<T>* statefulService, StatefulService<T> * statefulService,
AsyncWebServer* server, AsyncWebServer * server,
char const* webSocketPath, const char * webSocketPath,
size_t bufferSize = DEFAULT_BUFFER_SIZE) : size_t bufferSize = DEFAULT_BUFFER_SIZE)
WebSocketConnector<T>(statefulService, server, webSocketPath, bufferSize), : WebSocketConnector<T>(statefulService, server, webSocketPath, bufferSize)
WebSocketTx<T>(stateReader, statefulService, server, webSocketPath, bufferSize), , WebSocketTx<T>(stateReader, statefulService, server, webSocketPath, bufferSize)
WebSocketRx<T>(stateUpdater, statefulService, server, webSocketPath, bufferSize) { , WebSocketRx<T>(stateUpdater, statefulService, server, webSocketPath, bufferSize) {
} }
protected: protected:
void onWSEvent(AsyncWebSocket* server, void onWSEvent(AsyncWebSocket * server, AsyncWebSocketClient * client, AwsEventType type, void * arg, uint8_t * data, size_t len) {
AsyncWebSocketClient* client,
AwsEventType type,
void* arg,
uint8_t* data,
size_t len) {
WebSocketRx<T>::onWSEvent(server, client, type, arg, data, len); WebSocketRx<T>::onWSEvent(server, client, type, arg, data, len);
WebSocketTx<T>::onWSEvent(server, client, type, arg, data, len); WebSocketTx<T>::onWSEvent(server, client, type, arg, data, len);
} }

14
lib/framework/WiFiScanner.cpp
View File

@@ -1,17 +1,15 @@
#include <WiFiScanner.h> #include <WiFiScanner.h>
WiFiScanner::WiFiScanner(AsyncWebServer* server, SecurityManager* securityManager) { WiFiScanner::WiFiScanner(AsyncWebServer * server, SecurityManager * securityManager) {
server->on(SCAN_NETWORKS_SERVICE_PATH, server->on(SCAN_NETWORKS_SERVICE_PATH,
HTTP_GET, HTTP_GET,
securityManager->wrapRequest(std::bind(&WiFiScanner::scanNetworks, this, std::placeholders::_1), securityManager->wrapRequest(std::bind(&WiFiScanner::scanNetworks, this, std::placeholders::_1), AuthenticationPredicates::IS_ADMIN));
AuthenticationPredicates::IS_ADMIN));
server->on(LIST_NETWORKS_SERVICE_PATH, server->on(LIST_NETWORKS_SERVICE_PATH,
HTTP_GET, HTTP_GET,
securityManager->wrapRequest(std::bind(&WiFiScanner::listNetworks, this, std::placeholders::_1), securityManager->wrapRequest(std::bind(&WiFiScanner::listNetworks, this, std::placeholders::_1), AuthenticationPredicates::IS_ADMIN));
AuthenticationPredicates::IS_ADMIN));
}; };
void WiFiScanner::scanNetworks(AsyncWebServerRequest* request) { void WiFiScanner::scanNetworks(AsyncWebServerRequest * request) {
if (WiFi.scanComplete() != -1) { if (WiFi.scanComplete() != -1) {
WiFi.scanDelete(); WiFi.scanDelete();
WiFi.scanNetworks(true); WiFi.scanNetworks(true);
@@ -19,10 +17,10 @@ void WiFiScanner::scanNetworks(AsyncWebServerRequest* request) {
request->send(202); request->send(202);
} }
void WiFiScanner::listNetworks(AsyncWebServerRequest* request) { void WiFiScanner::listNetworks(AsyncWebServerRequest * request) {
int numNetworks = WiFi.scanComplete(); int numNetworks = WiFi.scanComplete();
if (numNetworks > -1) { if (numNetworks > -1) {
AsyncJsonResponse* response = new AsyncJsonResponse(false, MAX_WIFI_SCANNER_SIZE); AsyncJsonResponse * response = new AsyncJsonResponse(false, MAX_WIFI_SCANNER_SIZE);
JsonObject root = response->getRoot(); JsonObject root = response->getRoot();
JsonArray networks = root.createNestedArray("networks"); JsonArray networks = root.createNestedArray("networks");
for (int i = 0; i < numNetworks; i++) { for (int i = 0; i < numNetworks; i++) {

6
lib/framework/WiFiScanner.h
View File

@@ -21,11 +21,11 @@
class WiFiScanner { class WiFiScanner {
public: public:
WiFiScanner(AsyncWebServer* server, SecurityManager* securityManager); WiFiScanner(AsyncWebServer * server, SecurityManager * securityManager);
private: private:
void scanNetworks(AsyncWebServerRequest* request); void scanNetworks(AsyncWebServerRequest * request);
void listNetworks(AsyncWebServerRequest* request); void listNetworks(AsyncWebServerRequest * request);
#ifdef ESP8266 #ifdef ESP8266
uint8_t convertEncryptionType(uint8_t encryptionType); uint8_t convertEncryptionType(uint8_t encryptionType);

12
lib/framework/WiFiSettingsService.h
View File

@@ -37,7 +37,7 @@ class WiFiSettings {
IPAddress dnsIP1; IPAddress dnsIP1;
IPAddress dnsIP2; IPAddress dnsIP2;
static void read(WiFiSettings& settings, JsonObject& root) { static void read(WiFiSettings & settings, JsonObject & root) {
// connection settings // connection settings
root["ssid"] = settings.ssid; root["ssid"] = settings.ssid;
root["password"] = settings.password; root["password"] = settings.password;
@@ -52,8 +52,7 @@ class WiFiSettings {
JsonUtils::writeIP(root, "dns_ip_2", settings.dnsIP2); JsonUtils::writeIP(root, "dns_ip_2", settings.dnsIP2);
} }
static StateUpdateResult update(JsonObject& root, WiFiSettings& settings) { static StateUpdateResult update(JsonObject & root, WiFiSettings & settings) {
settings.ssid = root["ssid"] | FACTORY_WIFI_SSID; settings.ssid = root["ssid"] | FACTORY_WIFI_SSID;
settings.password = root["password"] | FACTORY_WIFI_PASSWORD; settings.password = root["password"] | FACTORY_WIFI_PASSWORD;
settings.hostname = root["hostname"] | FACTORY_WIFI_HOSTNAME; settings.hostname = root["hostname"] | FACTORY_WIFI_HOSTNAME;
@@ -75,8 +74,7 @@ class WiFiSettings {
// Turning off static ip config if we don't meet the minimum requirements // Turning off static ip config if we don't meet the minimum requirements
// of ipAddress, gateway and subnet. This may change to static ip only // of ipAddress, gateway and subnet. This may change to static ip only
// as sensible defaults can be assumed for gateway and subnet // as sensible defaults can be assumed for gateway and subnet
if (settings.staticIPConfig && if (settings.staticIPConfig && (settings.localIP == INADDR_NONE || settings.gatewayIP == INADDR_NONE || settings.subnetMask == INADDR_NONE)) {
(settings.localIP == INADDR_NONE || settings.gatewayIP == INADDR_NONE || settings.subnetMask == INADDR_NONE)) {
settings.staticIPConfig = false; settings.staticIPConfig = false;
} }
return StateUpdateResult::CHANGED; return StateUpdateResult::CHANGED;
@@ -85,7 +83,7 @@ class WiFiSettings {
class WiFiSettingsService : public StatefulService<WiFiSettings> { class WiFiSettingsService : public StatefulService<WiFiSettings> {
public: public:
WiFiSettingsService(AsyncWebServer* server, FS* fs, SecurityManager* securityManager); WiFiSettingsService(AsyncWebServer * server, FS * fs, SecurityManager * securityManager);
void begin(); void begin();
void loop(); void loop();
@@ -101,7 +99,7 @@ class WiFiSettingsService : public StatefulService<WiFiSettings> {
void onStationModeStop(WiFiEvent_t event, WiFiEventInfo_t info); void onStationModeStop(WiFiEvent_t event, WiFiEventInfo_t info);
#elif defined(ESP8266) #elif defined(ESP8266)
WiFiEventHandler _onStationModeDisconnectedHandler; WiFiEventHandler _onStationModeDisconnectedHandler;
void onStationModeDisconnected(const WiFiEventStationModeDisconnected& event); void onStationModeDisconnected(const WiFiEventStationModeDisconnected & event);
#endif #endif
void reconfigureWiFiConnection(); void reconfigureWiFiConnection();

15
lib/framework/WiFiStatus.cpp
View File

@@ -1,10 +1,9 @@
#include <WiFiStatus.h> #include <WiFiStatus.h>
WiFiStatus::WiFiStatus(AsyncWebServer* server, SecurityManager* securityManager) { WiFiStatus::WiFiStatus(AsyncWebServer * server, SecurityManager * securityManager) {
server->on(WIFI_STATUS_SERVICE_PATH, server->on(WIFI_STATUS_SERVICE_PATH,
HTTP_GET, HTTP_GET,
securityManager->wrapRequest(std::bind(&WiFiStatus::wifiStatus, this, std::placeholders::_1), securityManager->wrapRequest(std::bind(&WiFiStatus::wifiStatus, this, std::placeholders::_1), AuthenticationPredicates::IS_AUTHENTICATED));
AuthenticationPredicates::IS_AUTHENTICATED));
#ifdef ESP32 #ifdef ESP32
WiFi.onEvent(onStationModeConnected, WiFiEvent_t::SYSTEM_EVENT_STA_CONNECTED); WiFi.onEvent(onStationModeConnected, WiFiEvent_t::SYSTEM_EVENT_STA_CONNECTED);
WiFi.onEvent(onStationModeDisconnected, WiFiEvent_t::SYSTEM_EVENT_STA_DISCONNECTED); WiFi.onEvent(onStationModeDisconnected, WiFiEvent_t::SYSTEM_EVENT_STA_DISCONNECTED);
@@ -30,23 +29,23 @@ void WiFiStatus::onStationModeGotIP(WiFiEvent_t event, WiFiEventInfo_t info) {
// Serial.printf_P(PSTR("WiFi Got IP. localIP=%s, hostName=%s\r\n"), WiFi.localIP().toString().c_str(), WiFi.getHostname()); // Serial.printf_P(PSTR("WiFi Got IP. localIP=%s, hostName=%s\r\n"), WiFi.localIP().toString().c_str(), WiFi.getHostname());
} }
#elif defined(ESP8266) #elif defined(ESP8266)
void WiFiStatus::onStationModeConnected(const WiFiEventStationModeConnected& event) { void WiFiStatus::onStationModeConnected(const WiFiEventStationModeConnected & event) {
// Serial.print(F("WiFi Connected. SSID=")); // Serial.print(F("WiFi Connected. SSID="));
// Serial.println(event.ssid); // Serial.println(event.ssid);
} }
void WiFiStatus::onStationModeDisconnected(const WiFiEventStationModeDisconnected& event) { void WiFiStatus::onStationModeDisconnected(const WiFiEventStationModeDisconnected & event) {
// Serial.print(F("WiFi Disconnected. Reason code=")); // Serial.print(F("WiFi Disconnected. Reason code="));
// Serial.println(event.reason); // Serial.println(event.reason);
} }
void WiFiStatus::onStationModeGotIP(const WiFiEventStationModeGotIP& event) { void WiFiStatus::onStationModeGotIP(const WiFiEventStationModeGotIP & event) {
// Serial.printf_P(PSTR("WiFi Got IP. localIP=%s, hostName=%s\r\n"), event.ip.toString().c_str(), WiFi.hostname().c_str()); // Serial.printf_P(PSTR("WiFi Got IP. localIP=%s, hostName=%s\r\n"), event.ip.toString().c_str(), WiFi.hostname().c_str());
} }
#endif #endif
void WiFiStatus::wifiStatus(AsyncWebServerRequest* request) { void WiFiStatus::wifiStatus(AsyncWebServerRequest * request) {
AsyncJsonResponse* response = new AsyncJsonResponse(false, MAX_WIFI_STATUS_SIZE); AsyncJsonResponse * response = new AsyncJsonResponse(false, MAX_WIFI_STATUS_SIZE);
JsonObject root = response->getRoot(); JsonObject root = response->getRoot();
wl_status_t status = WiFi.status(); wl_status_t status = WiFi.status();
root["status"] = (uint8_t)status; root["status"] = (uint8_t)status;

10
lib/framework/WiFiStatus.h
View File

@@ -20,7 +20,7 @@
class WiFiStatus { class WiFiStatus {
public: public:
WiFiStatus(AsyncWebServer* server, SecurityManager* securityManager); WiFiStatus(AsyncWebServer * server, SecurityManager * securityManager);
private: private:
#ifdef ESP32 #ifdef ESP32
@@ -34,12 +34,12 @@ class WiFiStatus {
WiFiEventHandler _onStationModeDisconnectedHandler; WiFiEventHandler _onStationModeDisconnectedHandler;
WiFiEventHandler _onStationModeGotIPHandler; WiFiEventHandler _onStationModeGotIPHandler;
// static functions for logging WiFi events to the UART // static functions for logging WiFi events to the UART
static void onStationModeConnected(const WiFiEventStationModeConnected& event); static void onStationModeConnected(const WiFiEventStationModeConnected & event);
static void onStationModeDisconnected(const WiFiEventStationModeDisconnected& event); static void onStationModeDisconnected(const WiFiEventStationModeDisconnected & event);
static void onStationModeGotIP(const WiFiEventStationModeGotIP& event); static void onStationModeGotIP(const WiFiEventStationModeGotIP & event);
#endif #endif
void wifiStatus(AsyncWebServerRequest* request); void wifiStatus(AsyncWebServerRequest * request);
}; };
#endif // end WiFiStatus_h #endif // end WiFiStatus_h

4
lib_standalone/FSPersistence.h
View File

@@ -11,7 +11,7 @@ class FSPersistence {
JsonStateUpdater<T> stateUpdater, JsonStateUpdater<T> stateUpdater,
StatefulService<T> * statefulService, StatefulService<T> * statefulService,
FS * fs, FS * fs,
char const * filePath, const char * filePath,
size_t bufferSize = DEFAULT_BUFFER_SIZE) size_t bufferSize = DEFAULT_BUFFER_SIZE)
: _stateReader(stateReader) : _stateReader(stateReader)
, _stateUpdater(stateUpdater) , _stateUpdater(stateUpdater)
@@ -52,7 +52,7 @@ class FSPersistence {
JsonStateUpdater<T> _stateUpdater; JsonStateUpdater<T> _stateUpdater;
StatefulService<T> * _statefulService; StatefulService<T> * _statefulService;
FS * _fs; FS * _fs;
char const * _filePath; const char * _filePath;
size_t _bufferSize; size_t _bufferSize;
update_handler_id_t _updateHandlerId; update_handler_id_t _updateHandlerId;