esp-firewall/SourceCode/arduino/lib/Firewall/Firewall.cpp

#include "Firewall.h"

ESPFirewall::ESPFirewall(int port)
{
    log_i("Starting Firewall-API on %i", port);
    this->firewall_api = new AsyncWebServer(port);
    this->setup_routing();
}

void ESPFirewall::add_rule_to_firewall(firewall_rule_t *rule)
{
    firewall_rule_t *temp;
    if (head == NULL)
    {
        head = rule;
        rule->next = NULL;
        return;
    }
    temp = head;
    while (temp->next != NULL)
    {
        temp = temp->next;
    }
    temp->next = rule;
    rule->next = NULL;
    return;
}

firewall_rule_t *ESPFirewall::get_rule_from_firewall(int key)
{
    firewall_rule_t *rule_ptr = this->head;
    if (head == NULL)
    {
        return NULL;
    }
    while (rule_ptr->key != key)
    {
        if (rule_ptr->next == NULL)
        {
            return NULL;
        }
        else
        {
            rule_ptr = rule_ptr->next;
        }
    }
    return rule_ptr;
}

void ESPFirewall::setup_routing()
{
    firewall_api->on("^\\/api/v1/firewall\\/([0-9]+)$", HTTP_GET, std::bind(&ESPFirewall::get_firewall_rule_handler, this, std::placeholders::_1));
    firewall_api->on("/api/v1/firewall", HTTP_GET, std::bind(&ESPFirewall::get_firewall_rules_handler, this, std::placeholders::_1));
    firewall_api->on("/api/v1/firewall", HTTP_POST, std::bind(&ESPFirewall::post_firewall_handler, this, std::placeholders::_1));
    firewall_api->onNotFound(std::bind(&ESPFirewall::not_found, this, std::placeholders::_1));
    this->firewall_api->begin();
}

void ESPFirewall::json_message_response(AsyncWebServerRequest *request, String message, int response_code)
{
    DynamicJsonDocument json(256);
    String response;
    json["message"] = message;
    serializeJson(json, response);
    request->send(response_code, "application/json", response);
}

String ESPFirewall::construct_json_firewall_rule(firewall_rule_t *rule_ptr)
{
    StaticJsonDocument<192> doc;
    doc["key"] = rule_ptr->key;
    doc["source"] = rule_ptr->source;
    doc["destination"] = rule_ptr->destination;
    doc["protocol"] = rule_ptr->protocol;
    doc["target"] = rule_ptr->target;
    String response;
    serializeJson(doc, response);
    return response;
}

String ESPFirewall::construct_json_firewall()
{
    firewall_rule_t *rule_ptr = this->head;
    // Size for 12 Rules
    StaticJsonDocument<2048> doc;
    String response;
    doc["amount"] = amount_of_rules;
    JsonArray rules = doc.createNestedArray("rules");
    while (rule_ptr != NULL)
    {
        JsonObject rule = rules.createNestedObject();
        rule["key"] = rule_ptr->key;
        rule["source"] = rule_ptr->source;
        rule["destination"] = rule_ptr->destination;
        rule["protocol"] = rule_ptr->protocol;
        rule["target"] = rule_ptr->target;
        rule_ptr = rule_ptr->next;
    }
    serializeJson(doc, response);
    return response;
}

void ESPFirewall::not_found(AsyncWebServerRequest *request)
{
    json_message_response(request, "not found", 404);
}

void ESPFirewall::get_firewall_rule_handler(AsyncWebServerRequest *request)
{
    int rule_number = request->pathArg(0).toInt();
    firewall_rule_t *rule_ptr = get_rule_from_firewall(rule_number);
    if (rule_ptr == NULL)
    {
        json_message_response(request, "rule not found", 404);
    }
    else
    {
        request->send(200, "application/json", construct_json_firewall_rule(rule_ptr));
    }
}

void ESPFirewall::get_firewall_rules_handler(AsyncWebServerRequest *request)
{
    String response = construct_json_firewall();
    request->send(200, "application/json", response);
}

void ESPFirewall::post_firewall_handler(AsyncWebServerRequest *request)
{
    if (request_has_firewall_parameter(request))
    {
        firewall_rule_t *rule = (firewall_rule_t *)malloc(sizeof(firewall_rule_t));
        rule->key = ++amount_of_rules;

        String source = request->getParam("source")->value();
        strcpy(rule->source, source.length() <= IP4ADDR_STRLEN_MAX ? source.c_str() : "");
        String destination = request->getParam("destination")->value();
        strcpy(rule->destination, destination.length() <= IP4ADDR_STRLEN_MAX ? destination.c_str() : "");
        String protocol = request->getParam("protocol")->value();
        strcpy(rule->protocol, protocol.length() <= PROTOCOL_LENGTH ? protocol.c_str() : "");
        String target = request->getParam("target")->value();
        strcpy(rule->target, target.length() <= TARGET_LENGTH ? target.c_str() : "");

        add_rule_to_firewall(rule);
        json_message_response(request, "success", 200);
    }
    else
    {
        json_message_response(request, "not enough parameter", 200);
    }
}

bool ESPFirewall::request_has_firewall_parameter(AsyncWebServerRequest *request)
{
    return request->hasParam("source") || request->hasParam("destination") || request->hasParam("protocol") || request->hasParam("target");
}