147 lines
3.5 KiB
C++
147 lines
3.5 KiB
C++
#include "esp32Firewall.hpp"
|
|
|
|
namespace firewall
|
|
{
|
|
Firewall::Firewall()
|
|
{
|
|
this->amount_of_rules = retrieve_settings_value("amount_of_rules");
|
|
for (uint8_t i = 0; i < this->amount_of_rules; i++)
|
|
{
|
|
firewall_rule_t *rule_ptr = retrieve_firewall_rule(i);
|
|
add_rule_to_firewall(rule_ptr);
|
|
}
|
|
}
|
|
|
|
Firewall::~Firewall()
|
|
{
|
|
}
|
|
|
|
void Firewall::add_rule_to_firewall(firewall_rule_t *rule_ptr)
|
|
{
|
|
store_settings_value("amount_of_rules", this->amount_of_rules);
|
|
store_firewall_rule(rule_ptr);
|
|
firewall_rule_t *temp;
|
|
if (this->head == NULL)
|
|
{
|
|
this->head = rule_ptr;
|
|
rule_ptr->next = NULL;
|
|
return;
|
|
}
|
|
temp = this->head;
|
|
while (temp->next != NULL)
|
|
{
|
|
temp = temp->next;
|
|
}
|
|
temp->next = rule_ptr;
|
|
rule_ptr->next = NULL;
|
|
return;
|
|
}
|
|
|
|
firewall_rule_t *Firewall::get_rule_from_firewall(uint8_t key)
|
|
{
|
|
firewall_rule_t *rule_ptr = this->head;
|
|
if (this->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;
|
|
}
|
|
|
|
bool Firewall::delete_rule_from_firewall(uint8_t key)
|
|
{
|
|
if (this->head == NULL)
|
|
{
|
|
return false;
|
|
}
|
|
firewall_rule_t *current_rule_ptr = this->head;
|
|
firewall_rule_t *previous_rule_ptr = NULL;
|
|
firewall_rule_t *temp = NULL;
|
|
while (current_rule_ptr->key != key)
|
|
{
|
|
if (current_rule_ptr->next == NULL)
|
|
{
|
|
return false;
|
|
}
|
|
else
|
|
{
|
|
previous_rule_ptr = current_rule_ptr;
|
|
current_rule_ptr = current_rule_ptr->next;
|
|
}
|
|
}
|
|
if (current_rule_ptr == this->head)
|
|
{
|
|
this->head = head->next;
|
|
temp = this->head;
|
|
}
|
|
else
|
|
{
|
|
previous_rule_ptr->next = current_rule_ptr->next;
|
|
temp = previous_rule_ptr->next;
|
|
}
|
|
while (temp != NULL)
|
|
{
|
|
temp->key--;
|
|
temp = temp->next;
|
|
}
|
|
free(current_rule_ptr);
|
|
this->amount_of_rules--;
|
|
return true;
|
|
}
|
|
|
|
String Firewall::protocol_to_string(firewall_protocol_t &protocol)
|
|
{
|
|
switch (protocol)
|
|
{
|
|
case FW_TCP:
|
|
return "TCP";
|
|
case FW_UDP:
|
|
return "UDP";
|
|
default:
|
|
return "ALL";
|
|
}
|
|
}
|
|
|
|
firewall_protocol_t Firewall::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 Firewall::target_to_string(firewall_target_t &target)
|
|
{
|
|
switch (target)
|
|
{
|
|
case FW_REJECT:
|
|
return "REJECT";
|
|
case FW_DROP:
|
|
return "DROP";
|
|
default:
|
|
return "ACCEPT";
|
|
}
|
|
}
|
|
|
|
firewall_target_t Firewall::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;
|
|
}
|
|
}
|