introduce namespace

SourceCode/arduino/lib/Firewall/esp32Eeprom.cpp

@@ -1,11 +1,26 @@
 #include "esp32Eeprom.hpp"
 
-esp32Eeprom::esp32Eeprom(const uint16_t eeprom_size)
+namespace firewall
 {
+    Storage::Storage(const uint16_t eeprom_size)
+    {
         this->eeprom_size = eeprom_size;
         EEPROM.begin(this->eeprom_size);
-}
+        set_amount_of_firewall_rules(EEPROM.read(this->settings_head));
+        log_i("Amount of Rules: %i", get_amount_of_firewall_rules());
+    }
 
-esp32Eeprom::~esp32Eeprom()
+    Storage::~Storage()
-{
+    {
+    }
+
+    uint8_t Storage::get_amount_of_firewall_rules()
+    {
+        return this->amount_of_rules;
+    }
+
+    void Storage::set_amount_of_firewall_rules(const uint8_t new_amount)
+    {
+        this->amount_of_rules = new_amount;
+    }
 }

SourceCode/arduino/lib/Firewall/esp32Eeprom.hpp

@@ -2,15 +2,30 @@
 #define ESP32_EEPROM_HPP
 
 #include "EEPROM.h"
+#include "FirewallTypes.h"
 
-class esp32Eeprom
+namespace firewall
 {
-private:
+    class Storage
+    {
+    private:
         uint16_t eeprom_size;
+        uint16_t settings_start = 0;
+        uint16_t settings_head = settings_start;
+        uint16_t rules_start = 1000;
+        uint16_t rules_head = rules_start;
+        uint16_t certificate_start = 3000;
+        uint16_t certificate_head = certificate_start;
 
-public:
+    protected:
-    esp32Eeprom(const uint16_t);
+        uint8_t amount_of_rules;
-    ~esp32Eeprom();
+        uint8_t get_amount_of_firewall_rules();
-};
+        void set_amount_of_firewall_rules(const uint8_t);
+
+    public:
+        Storage(const uint16_t = 4000);
+        ~Storage();
+    };
+}
 
 #endif

SourceCode/arduino/lib/Firewall/esp32Firewall.cpp

@@ -1,16 +1,18 @@
 #include "esp32Firewall.hpp"
 
-esp32Firewall::esp32Firewall()
+namespace firewall
 {
+    esp32Firewall::esp32Firewall()
+    {
         this->setup_eeprom();
-}
+    }
 
-esp32Firewall::~esp32Firewall()
+    esp32Firewall::~esp32Firewall()
-{
+    {
-}
+    }
 
-String esp32Firewall::protocol_to_string(firewall_protocol_t &protocol)
+    String esp32Firewall::protocol_to_string(firewall_protocol_t &protocol)
-{
+    {
         switch (protocol)
         {
         case FW_TCP:
@@ -20,20 +22,20 @@ String esp32Firewall::protocol_to_string(firewall_protocol_t &protocol)
         default:
             return "ALL";
         }
-}
+    }
 
-firewall_protocol_t esp32Firewall::string_to_protocol(std::string &protocol)
+    firewall_protocol_t esp32Firewall::string_to_protocol(std::string &protocol)
-{
+    {
         if (protocol.compare("TCP") == 0)
             return FW_TCP;
         else if (protocol.compare("UDP") == 0)
             return FW_UDP;
         else
             return FW_ALL;
-}
+    }
 
-String esp32Firewall::target_to_string(firewall_target_t &target)
+    String esp32Firewall::target_to_string(firewall_target_t &target)
-{
+    {
         switch (target)
         {
         case FW_REJECT:
@@ -43,20 +45,20 @@ String esp32Firewall::target_to_string(firewall_target_t &target)
         default:
             return "ACCEPT";
         }
-}
+    }
 
-firewall_target_t esp32Firewall::string_to_target(std::string &target)
+    firewall_target_t esp32Firewall::string_to_target(std::string &target)
-{
+    {
         if (target.compare("REJECT") == 0)
             return FW_REJECT;
         else if (target.compare("DROP") == 0)
             return FW_DROP;
         else
             return FW_ACCEPT;
-}
+    }
 
-void esp32Firewall::setup_eeprom()
+    void esp32Firewall::setup_eeprom()
-{
+    {
         EEPROM.begin(this->eeprom_size);
         this->amount_of_rules = EEPROM.read(this->eeprom_settings_head);
         uint8_t security_number = EEPROM.read(this->eeprom_settings_head + 1);
@@ -69,10 +71,10 @@ void esp32Firewall::setup_eeprom()
         }
         log_i("Amount of existing Rules %i", this->amount_of_rules);
         this->eeprom_read_firewall_rules();
-}
+    }
 
-void esp32Firewall::eeprom_write_firewall_rule(firewall_rule_t *rule_ptr)
+    void esp32Firewall::eeprom_write_firewall_rule(firewall_rule_t *rule_ptr)
-{
+    {
         EEPROM.write(this->eeprom_settings_head, this->amount_of_rules);
         EEPROM.writeString(this->eeprom_rules_head, rule_ptr->source);
         this->eeprom_rules_head += IPV4ADDRESS_LENGTH;
@@ -83,10 +85,10 @@ void esp32Firewall::eeprom_write_firewall_rule(firewall_rule_t *rule_ptr)
         EEPROM.write(this->eeprom_rules_head, rule_ptr->target);
         this->eeprom_rules_head += sizeof(firewall_target_t);
         EEPROM.commit();
-}
+    }
 
-void esp32Firewall::eeprom_write_firewall_rules()
+    void esp32Firewall::eeprom_write_firewall_rules()
-{
+    {
         this->eeprom_rules_head = eeprom_start_firewall_rules;
         firewall_rule_t *rule_ptr = this->head;
         while (rule_ptr != NULL)
@@ -94,10 +96,10 @@ void esp32Firewall::eeprom_write_firewall_rules()
             this->eeprom_write_firewall_rule(rule_ptr);
             rule_ptr = rule_ptr->next;
         }
-}
+    }
 
-void esp32Firewall::eeprom_read_firewall_rule(uint8_t &eeprom_address, uint8_t &rule_nr)
+    void esp32Firewall::eeprom_read_firewall_rule(uint8_t &eeprom_address, uint8_t &rule_nr)
-{
+    {
         firewall_rule_t *rule_ptr = (firewall_rule_t *)malloc(sizeof(firewall_rule_t));
         rule_ptr->key = rule_nr;
         strcpy(rule_ptr->source, EEPROM.readString(eeprom_address).c_str());
@@ -114,19 +116,19 @@ void esp32Firewall::eeprom_read_firewall_rule(uint8_t &eeprom_address, uint8_t &
               rule_ptr->destination,
               protocol_to_string(rule_ptr->protocol),
               target_to_string(rule_ptr->target));
-}
+    }
 
-void esp32Firewall::eeprom_read_firewall_rules()
+    void esp32Firewall::eeprom_read_firewall_rules()
-{
+    {
         uint8_t eeprom_address = eeprom_start_firewall_rules;
         for (uint8_t i = 1; i <= this->amount_of_rules; i++)
         {
             eeprom_read_firewall_rule(eeprom_address, i);
         }
-}
+    }
 
-void esp32Firewall::add_rule_to_firewall(firewall_rule_t *rule_ptr)
+    void esp32Firewall::add_rule_to_firewall(firewall_rule_t *rule_ptr)
-{
+    {
         firewall_rule_t *temp;
         if (this->head == NULL)
         {
@@ -142,10 +144,10 @@ void esp32Firewall::add_rule_to_firewall(firewall_rule_t *rule_ptr)
         temp->next = rule_ptr;
         rule_ptr->next = NULL;
         return;
-}
+    }
 
-firewall_rule_t *esp32Firewall::get_rule_from_firewall(uint8_t key)
+    firewall_rule_t *esp32Firewall::get_rule_from_firewall(uint8_t key)
-{
+    {
         firewall_rule_t *rule_ptr = this->head;
         if (this->head == NULL)
         {
@@ -163,10 +165,10 @@ firewall_rule_t *esp32Firewall::get_rule_from_firewall(uint8_t key)
             }
         }
         return rule_ptr;
-}
+    }
 
-bool esp32Firewall::delete_rule_from_firewall(uint8_t key)
+    bool esp32Firewall::delete_rule_from_firewall(uint8_t key)
-{
+    {
         if (this->head == NULL)
         {
             return false;
@@ -205,4 +207,5 @@ bool esp32Firewall::delete_rule_from_firewall(uint8_t key)
         this->amount_of_rules--;
         this->eeprom_write_firewall_rules();
         return true;
+    }
 }

SourceCode/arduino/lib/Firewall/esp32Firewall.hpp

@@ -6,9 +6,11 @@
 
 #define eeprom_start_firewall_rules 4
 
-class esp32Firewall
+namespace firewall
 {
-private:
+    class esp32Firewall
+    {
+    private:
         uint16_t eeprom_size = 512;
         uint8_t security_number = 93;
         int eeprom_settings_head = 0;
@@ -19,7 +21,7 @@ private:
         void eeprom_read_firewall_rule(uint8_t &, uint8_t &);
         void eeprom_read_firewall_rules();
 
-protected:
+    protected:
         uint8_t amount_of_rules = 0;
         struct firewall_rule *head = NULL;
 
@@ -34,9 +36,10 @@ protected:
         String target_to_string(firewall_target_t &);
         firewall_target_t string_to_target(std::string &);
 
-public:
+    public:
         esp32Firewall();
         ~esp32Firewall();
-};
+    };
+}
 
 #endif

SourceCode/arduino/lib/Firewall/esp32FirewallAPI.cpp

@@ -1,7 +1,9 @@
 #include "esp32FirewallAPI.hpp"
 
-esp32FirewallApi::esp32FirewallApi(const uint16_t port)
+namespace firewall
 {
+    esp32FirewallApi::esp32FirewallApi(const uint16_t port)
+    {
         this->setup_certificate();
         this->server = new HTTPSServer(this->certificate, port, 5);
         this->setup_routing();
@@ -11,19 +13,19 @@ esp32FirewallApi::esp32FirewallApi(const uint16_t port)
         {
             log_i("Server ready.");
         }
-}
+    }
 
-esp32FirewallApi::~esp32FirewallApi()
+    esp32FirewallApi::~esp32FirewallApi()
-{
+    {
-}
+    }
 
-void esp32FirewallApi::handle_clients()
+    void esp32FirewallApi::handle_clients()
-{
+    {
         this->server->loop();
-}
+    }
 
-void esp32FirewallApi::setup_certificate()
+    void esp32FirewallApi::setup_certificate()
-{
+    {
         log_i("Creating the certificate...");
         this->certificate = new SSLCert();
         int createCertResult = createSelfSignedCert(
@@ -39,10 +41,10 @@ void esp32FirewallApi::setup_certificate()
                 delay(500);
         }
         log_i("Creating the certificate was successful");
-}
+    }
 
-void esp32FirewallApi::setup_routing()
+    void esp32FirewallApi::setup_routing()
-{
+    {
         ResourceNode *get_firewall_rule = new ResourceNode("/api/v1/firewall/*", "GET", std::bind(&esp32FirewallApi::get_firewall_rule_handler, this, std::placeholders::_1, std::placeholders::_2));
         ResourceNode *get_firewall_rules = new ResourceNode("/api/v1/firewall", "GET", std::bind(&esp32FirewallApi::get_firewall_rules_handler, this, std::placeholders::_1, std::placeholders::_2));
         ResourceNode *post_firewall = new ResourceNode("/api/v1/firewall", "POST", std::bind(&esp32FirewallApi::post_firewall_handler, this, std::placeholders::_1, std::placeholders::_2));
@@ -55,22 +57,22 @@ void esp32FirewallApi::setup_routing()
         this->server->registerNode(delete_firewall);
         this->server->registerNode(restart_device);
         this->server->setDefaultNode(not_found);
-}
+    }
 
-void esp32FirewallApi::restart_device_handler(HTTPRequest *request, HTTPResponse *response)
+    void esp32FirewallApi::restart_device_handler(HTTPRequest *request, HTTPResponse *response)
-{
+    {
         this->json_message_response(response, "restarting device in 2 sec", 200);
         sleep(2000);
         esp_restart();
-}
+    }
 
-void esp32FirewallApi::not_found_handler(HTTPRequest *request, HTTPResponse *response)
+    void esp32FirewallApi::not_found_handler(HTTPRequest *request, HTTPResponse *response)
-{
+    {
         this->json_message_response(response, "not found", 404);
-}
+    }
 
-void esp32FirewallApi::get_firewall_rule_handler(HTTPRequest *request, HTTPResponse *response)
+    void esp32FirewallApi::get_firewall_rule_handler(HTTPRequest *request, HTTPResponse *response)
-{
+    {
         ResourceParameters *params = request->getParams();
         int rule_number = atoi(params->getPathParameter(0).c_str());
         firewall_rule_t *rule_ptr = this->get_rule_from_firewall(rule_number);
@@ -84,20 +86,20 @@ void esp32FirewallApi::get_firewall_rule_handler(HTTPRequest *request, HTTPRespo
             response->setStatusCode(200);
             response->print(this->construct_json_firewall_rule(rule_ptr));
         }
-}
+    }
 
-void esp32FirewallApi::get_firewall_rules_handler(HTTPRequest *request, HTTPResponse *response)
+    void esp32FirewallApi::get_firewall_rules_handler(HTTPRequest *request, HTTPResponse *response)
-{
+    {
         this->json_generic_response(response, this->construct_json_firewall(), 200);
-}
+    }
 
-bool esp32FirewallApi::request_has_firewall_parameter(ResourceParameters *params)
+    bool esp32FirewallApi::request_has_firewall_parameter(ResourceParameters *params)
-{
+    {
         return params->isQueryParameterSet("source") || params->isQueryParameterSet("destination") || params->isQueryParameterSet("protocol") || params->isQueryParameterSet("target");
-}
+    }
 
-void esp32FirewallApi::post_firewall_handler(HTTPRequest *request, HTTPResponse *response)
+    void esp32FirewallApi::post_firewall_handler(HTTPRequest *request, HTTPResponse *response)
-{
+    {
         ResourceParameters *params = request->getParams();
         if (request_has_firewall_parameter(params))
         {
@@ -127,10 +129,10 @@ void esp32FirewallApi::post_firewall_handler(HTTPRequest *request, HTTPResponse
         {
             this->json_message_response(response, "not enough parameter", 400);
         }
-}
+    }
 
-void esp32FirewallApi::delete_firewall_handler(HTTPRequest *request, HTTPResponse *response)
+    void esp32FirewallApi::delete_firewall_handler(HTTPRequest *request, HTTPResponse *response)
-{
+    {
         ResourceParameters *params = request->getParams();
         int rule_number = atoi(params->getPathParameter(0).c_str());
         if (this->delete_rule_from_firewall(rule_number))
@@ -141,17 +143,17 @@ void esp32FirewallApi::delete_firewall_handler(HTTPRequest *request, HTTPRespons
         {
             this->json_message_response(response, "cannot delete firewall rule", 500);
         }
-}
+    }
 
-void esp32FirewallApi::json_generic_response(HTTPResponse *response, String serialized, const uint16_t response_code)
+    void esp32FirewallApi::json_generic_response(HTTPResponse *response, String serialized, const uint16_t response_code)
-{
+    {
         response->setHeader("Content-Type", "application/json");
         response->setStatusCode(response_code);
         response->println(serialized);
-}
+    }
 
-void esp32FirewallApi::json_message_response(HTTPResponse *response, String message, const uint16_t response_code)
+    void esp32FirewallApi::json_message_response(HTTPResponse *response, String message, const uint16_t response_code)
-{
+    {
         response->setHeader("Content-Type", "application/json");
         response->setStatusCode(response_code);
         StaticJsonDocument<96> json;
@@ -159,10 +161,10 @@ void esp32FirewallApi::json_message_response(HTTPResponse *response, String mess
         json["message"] = message;
         serializeJson(json, serialized);
         response->println(serialized);
-}
+    }
 
-String esp32FirewallApi::construct_json_firewall_rule(firewall_rule_t *rule_ptr)
+    String esp32FirewallApi::construct_json_firewall_rule(firewall_rule_t *rule_ptr)
-{
+    {
         StaticJsonDocument<256> doc;
         doc["key"] = rule_ptr->key;
         doc["source"] = rule_ptr->source;
@@ -172,10 +174,10 @@ String esp32FirewallApi::construct_json_firewall_rule(firewall_rule_t *rule_ptr)
         String response;
         serializeJson(doc, response);
         return response;
-}
+    }
 
-String esp32FirewallApi::construct_json_firewall()
+    String esp32FirewallApi::construct_json_firewall()
-{
+    {
         firewall_rule_t *rule_ptr = this->head;
         // Size for approx. 12 Rules
         StaticJsonDocument<2048> doc;
@@ -194,4 +196,5 @@ String esp32FirewallApi::construct_json_firewall()
         }
         serializeJson(doc, response);
         return response;
+    }
 }

SourceCode/arduino/lib/Firewall/esp32FirewallAPI.hpp

@@ -11,9 +11,11 @@
 
 using namespace httpsserver;
 
-class esp32FirewallApi : public esp32Firewall
+namespace firewall
 {
-private:
+    class esp32FirewallApi : public esp32Firewall
+    {
+    private:
         HTTPSServer *server;
         SSLCert *certificate;
 
@@ -32,10 +34,11 @@ private:
         String construct_json_firewall_rule(firewall_rule_t *);
         String construct_json_firewall();
 
-public:
+    public:
         esp32FirewallApi(const uint16_t = 8080);
         ~esp32FirewallApi();
         void handle_clients();
-};
+    };
+}
 
 #endif

SourceCode/arduino/src/main.cpp

@@ -1,10 +1,11 @@
 #include "theSecrets.h"
 #include "WiFi.h"
 
-#include "esp32Firewall.hpp"
 #include "esp32FirewallAPI.hpp"
+#include "esp32Eeprom.hpp"
 
-esp32FirewallApi *firewall_api;
+firewall::esp32FirewallApi *firewall_api;
+firewall::Storage *storage;
 
 void setup_wifi()
 {
@@ -24,10 +25,11 @@ void setup_wifi()
 void setup()
 {
   setup_wifi();
-  firewall_api = new esp32FirewallApi;
+  // firewall_api = new esp32FirewallApi;
+  storage = new firewall::Storage;
 }
 
 void loop()
 {
-  firewall_api->handle_clients();
+  // firewall_api->handle_clients();
 }