simplify more

ESPFirewall/lib/Firewall/src/API.cpp

@@ -2,8 +2,10 @@
 
 namespace fw
 {
-    API::API(const char *cert, const char *key, const char *username, const char *password, const uint16_t port)
+    API::API(const char *cert, const char *key, const char *username, const char *password, const String ip, const uint16_t port)
     {
+        this->server_ip = ip;
+        this->server_port = port;
         if (this->setup_auth(username, password) == ERROR)
             endless_loop();
 #ifdef ESP32
@@ -52,7 +54,7 @@ namespace fw
         }
         else
         {
-            this->json_message_response("unauthorized", 403);
+            this->json_message_response("please provide username and password", 403);
             return DENIED;
         }
     }
@@ -67,23 +69,28 @@ namespace fw
         add_api_endpoint("/firewall", "GET", "Get all Firewall Rules");
 
         this->server->on(UriRegex("/firewall/([0-9]+)"), HTTP_GET, std::bind(&API::get_firewall_rule_handler, this));
-        add_api_endpoint("/firewall/key", "GET", "Get Firewall Rule by key");
+        add_api_endpoint("/firewall/1", "GET", "Get Firewall Rule by key");
 
         this->server->on("/firewall", HTTP_POST, std::bind(&API::post_firewall_handler, this));
         add_api_endpoint("/firewall", "POST", "Create Firewall Rule");
 
         this->server->on(UriRegex("/firewall/([0-9]+)"), HTTP_DELETE, std::bind(&API::delete_firewall_handler, this));
-        add_api_endpoint("/firewall/key", "DELETE", "Delete Firewall Rule by key");
+        add_api_endpoint("/firewall/1", "DELETE", "Delete Firewall Rule by key");
 
         this->server->onNotFound(std::bind(&API::not_found_handler, this));
     }
 
-    void API::add_api_endpoint(const char *uri, const char *method, const char *description)
+    void API::add_api_endpoint(const String uri, const char *method, const char *description)
     {
         api_endpoint_t *temp;
+#ifdef ESP32
+        const String url = "http://" + this->server_ip + ":" + this->server_port + uri;
+#elif defined(ESP8266)
+        const String url = "https://" + this->server_ip + ":" + this->server_port + uri;
+#endif
 
         api_endpoint_t *api_ptr = (api_endpoint_t *)malloc(sizeof(api_endpoint_t));
-        strncpy(api_ptr->uri, uri, sizeof(api_ptr->uri));
+        strncpy(api_ptr->uri, url.c_str(), sizeof(api_ptr->uri));
         strncpy(api_ptr->method, method, sizeof(api_ptr->method));
         strncpy(api_ptr->description, description, sizeof(api_ptr->description));
 
@@ -105,7 +112,8 @@ namespace fw
 
     void API::not_found_handler()
     {
-        this->json_generic_response(this->construct_json_endpoints(), 404);
+        uint16_t response_code = 404;
+        this->json_generic_response(this->construct_json_api(response_code), response_code);
     }
 
     void API::get_firewall_rule_handler()
@@ -116,7 +124,7 @@ namespace fw
         int rule_number = atoi(param.c_str());
         firewall_rule_t *rule_ptr = get_rule_from_firewall(rule_number);
         if (rule_ptr == NULL)
-            this->json_message_response("rule not found", 404);
+            this->json_message_response("rule does not exist", 404);
         else
             this->json_generic_response(construct_json_firewall_rule(rule_ptr), 200);
     }
@@ -143,7 +151,7 @@ namespace fw
         }
         else
         {
-            this->json_message_response("not enough parameter", 400);
+            this->json_message_response("not enough parameter provided", 400);
         }
     }
 
@@ -194,6 +202,7 @@ namespace fw
     void API::json_message_response(String message, const uint16_t response_code)
     {
         String serialized_string = "{";
+        serialized_string += json_new_attribute("status", response_code_to_string(response_code));
         serialized_string += json_new_attribute("message", message, true);
         serialized_string += "}";
         this->server->send(response_code, "application/json; charset=utf-8", serialized_string);
@@ -215,7 +224,7 @@ namespace fw
     {
         firewall_rule_t *rule_ptr = rule_head;
         String serialized_string = "{";
-        serialized_string += json_new_attribute("amount_of_rules", amount_of_rules);
+        serialized_string += json_new_attribute("status", response_code_to_string(200));
         serialized_string += "\"rules\": [";
         while (rule_ptr != NULL)
         {
@@ -228,7 +237,7 @@ namespace fw
         return serialized_string;
     }
 
-    String API::construct_json_endpoint(api_endpoint_t *api_ptr)
+    String API::construct_json_api_endpoint(api_endpoint_t *api_ptr)
     {
         String serialized_string = "{";
         serialized_string += json_new_attribute("endpoint", api_ptr->uri);
@@ -238,15 +247,15 @@ namespace fw
         return serialized_string;
     }
 
-    String API::construct_json_endpoints()
+    String API::construct_json_api(const uint16_t response_code)
     {
         api_endpoint_t *api_ptr = this->endpoint_head;
         String serialized_string = "{";
-        serialized_string += json_new_attribute("message", "route not found");
+        serialized_string += json_new_attribute("status", response_code_to_string(response_code));
         serialized_string += "\"endpoints\": [";
         while (api_ptr != NULL)
         {
-            serialized_string += construct_json_endpoint(api_ptr);
+            serialized_string += construct_json_api_endpoint(api_ptr);
             api_ptr = api_ptr->next;
             if (api_ptr != NULL)
                 serialized_string += ",";

ESPFirewall/lib/Firewall/src/API.hpp

@@ -16,7 +16,7 @@ namespace fw
 {
     typedef struct api_endpoints
     {
-        char uri[20];
+        char uri[40];
         char method[7];
         char description[30];
         struct api_endpoints *next;
@@ -38,7 +38,7 @@ namespace fw
         auth_t check_auth();
 
         void setup_routing(const char *cert, const char *key);
-        void add_api_endpoint(const char *uri, const char *method, const char *description);
+        void add_api_endpoint(const String uri, const char *method, const char *description);
         void get_firewall_rule_handler();
         void get_firewall_rules_handler();
         void post_firewall_handler();
@@ -52,14 +52,17 @@ namespace fw
         void json_message_response(String message, const uint16_t response_code);
         String construct_json_firewall_rule(firewall_rule_t *);
         String construct_json_firewall();
-        String construct_json_endpoint(api_endpoint_t *);
+        String construct_json_api_endpoint(api_endpoint_t *);
-        String construct_json_endpoints();
+        String construct_json_api(const uint16_t response_code);
+        String construct_json_array(String message, String array_name);
 
     protected:
+        String server_ip;
+        uint16_t server_port;
         void handle_client();
 
     public:
-        API(const char *cert, const char *key, const char *username, const char *password, const uint16_t port);
+        API(const char *cert, const char *key, const char *username, const char *password, const String ip, const uint16_t port);
         ~API();
     };
 }

ESPFirewall/lib/Firewall/src/Firewall.hpp

@@ -9,13 +9,13 @@ namespace fw
     {
     private:
     public:
-        Firewall(const char *, const char *, const char *, const char *, const uint16_t = 8080);
+        Firewall(const char *, const char *, const char *, const char *, const String ip, const uint16_t = 8080);
         ~Firewall();
         void handle_api_client();
     };
 
-    Firewall::Firewall(const char *cert, const char *key, const char *username, const char *password, const uint16_t port)
+    Firewall::Firewall(const char *cert, const char *key, const char *username, const char *password, const String ip, const uint16_t port)
-        : API(cert, key, username, password, port) {}
+        : API(cert, key, username, password, ip, port) {}
     Firewall::~Firewall() {}
     void Firewall::handle_api_client()
     {

ESPFirewall/lib/Firewall/src/Utils.cpp

@@ -48,6 +48,23 @@ namespace fw
             return TARGET_ACCEPT;
     }
 
+    String response_code_to_string(const uint16_t response_code)
+    {
+        switch (response_code)
+        {
+        case 200:
+            return "success";
+        case 403:
+            return "unauthorized";
+        case 404:
+            return "not found";
+        case 500:
+            return "server error";
+        default:
+            return "unknown error";
+        }
+    }
+
     void endless_loop()
     {
         Serial.printf("Something went wrong. Running endless loop until fixed...");

ESPFirewall/lib/Firewall/src/Utils.hpp

@@ -56,6 +56,7 @@ namespace fw
     firewall_protocol_t string_to_protocol(String &protocol);
     String target_to_string(firewall_target_t &target);
     firewall_target_t string_to_target(String &target);
+    String response_code_to_string(const uint16_t response_code);
     void endless_loop();
 }
 

ESPFirewall/src/main.cpp

@@ -10,6 +10,7 @@
 #include "Firewall.hpp"
 
 fw::Firewall *firewall;
+String ip = "0.0.0.0";
 
 void setup_wifi()
 {
@@ -24,13 +25,14 @@ void setup_wifi()
   }
   Serial.println();
   Serial.print("IP Address: ");
-  Serial.println(WiFi.localIP());
+  ip = WiFi.localIP().toString();
+  Serial.println(ip);
 }
 
 void setup()
 {
   setup_wifi();
-  firewall = new fw::Firewall(cert, key, username, password, 8080);
+  firewall = new fw::Firewall(cert, key, username, password, ip, 8080);
 }
 
 void loop()