Feat/adjv3 protections

Inc/HALAL/Models/Packets/Order.hpp

@@ -12,6 +12,7 @@
 class Order : public Packet {
 public:
     string* remote_ip;
+    static inline uint16_t last_order_ip = 0;
     static map<uint16_t, Order*> orders;
     virtual void set_callback(void (*callback)(void)) = 0;
     virtual void process() = 0;

Inc/ST-LIB_HIGH/Protections/ProtectionMessages.hpp

@@ -31,8 +31,11 @@ struct ProtectionADJv3Packet {
     };
 
 public:
-    static Package
-    make(uint16_t measurement_id, Protections::RuleKind protection, Protections::SampleEncoding value_size);
+    static Package make(
+        uint16_t measurement_id,
+        Protections::RuleKind protection,
+        Protections::SampleEncoding value_size
+    );
     static bool tcp_client_init(const char* ip, uint16_t port);
     static bool tcp_client_send(Package& pack, const void* value);
 

Src/HALAL/Services/Communication/Ethernet/LWIP/TCP/ServerSocket.cpp

@@ -3,12 +3,15 @@
  *
  *  Created on: Nov 23, 2022
  *      Author: stefa
+ *  Edited on: Nov 6, 2026
+ *      Editor: aleks
  */
 #ifdef STLIB_ETH
 #include "HALAL/Services/Communication/Ethernet/LWIP/TCP/ServerSocket.hpp"
 #include "HALAL/Services/Communication/Ethernet/LWIP/TCP/TcpOrderStreamParser.hpp"
 #include "ErrorHandler/ErrorHandler.hpp"
 #include "lwip/priv/tcp_priv.h"
+#include "ST-LIB_HIGH/Protections/ProtectionMessages.hpp"
 #ifdef HAL_ETH_MODULE_ENABLED
 
 uint8_t ServerSocket::priority = 1;
@@ -202,6 +205,10 @@ void ServerSocket::close() {
     rx_stream_buffer.clear();
     state = CLOSED;
 
+    ST_LIB::ProtectionADJv3Packet::tpcb =
+        nullptr; // Protection from hard Fault (idk how it works by the moment)
+    ST_LIB::ProtectionADJv3Packet::is_connected = false;
+
     auto listener_it = listening_sockets.find(local_port);
     if (listener_it != listening_sockets.end() && listener_it->second == this) {
         listening_sockets.erase(listener_it);
@@ -362,43 +369,43 @@ bool ServerSocket::is_listening() const { return state == ServerSocket::ServerSt
 
 err_t ServerSocket::accept_callback(
     void* arg,
-    struct tcp_pcb* incomming_control_block,
+    struct tcp_pcb* incoming_control_block,
     err_t error
 ) {
-    if (error != ERR_OK || incomming_control_block == nullptr) {
-        if (incomming_control_block != nullptr) {
-            tcp_abort(incomming_control_block);
+    if (error != ERR_OK || incoming_control_block == nullptr) {
+        if (incoming_control_block != nullptr) {
+            tcp_abort(incoming_control_block);
         }
         return error;
     }
 
     ServerSocket* server_socket = static_cast<ServerSocket*>(arg);
     if (server_socket == nullptr) {
-        auto it = listening_sockets.find(incomming_control_block->local_port);
+        auto it = listening_sockets.find(incoming_control_block->local_port);
         if (it == listening_sockets.end()) {
-            tcp_abort(incomming_control_block);
+            tcp_abort(incoming_control_block);
             return ERR_ABRT;
         }
         server_socket = it->second;
     }
 
     server_socket->state = ACCEPTED;
-    server_socket->client_control_block = incomming_control_block;
-    server_socket->remote_ip = IPV4(incomming_control_block->remote_ip);
+    server_socket->client_control_block = incoming_control_block;
+    server_socket->remote_ip = IPV4(incoming_control_block->remote_ip);
     server_socket->rx_packet_buffer = {};
     server_socket->rx_stream_buffer.clear();
     server_socket->rx_stream_buffer.reserve(TcpOrderStreamParser::MAX_RX_STREAM_BUFFER_BYTES);
 
-    tcp_setprio(incomming_control_block, priority);
-    tcp_nagle_disable(incomming_control_block);
-    ip_set_option(incomming_control_block, SOF_REUSEADDR);
+    tcp_setprio(incoming_control_block, priority);
+    tcp_nagle_disable(incoming_control_block);
+    ip_set_option(incoming_control_block, SOF_REUSEADDR);
 
-    tcp_arg(incomming_control_block, server_socket);
-    tcp_recv(incomming_control_block, receive_callback);
-    tcp_sent(incomming_control_block, send_callback);
-    tcp_err(incomming_control_block, error_callback);
-    tcp_poll(incomming_control_block, poll_callback, 1);
-    config_keepalive(incomming_control_block, server_socket);
+    tcp_arg(incoming_control_block, server_socket);
+    tcp_recv(incoming_control_block, receive_callback);
+    tcp_sent(incoming_control_block, send_callback);
+    tcp_err(incoming_control_block, error_callback);
+    tcp_poll(incoming_control_block, poll_callback, 1);
+    config_keepalive(incoming_control_block, server_socket);
 
     if (server_socket->server_control_block != nullptr) {
         tcp_arg(server_socket->server_control_block, nullptr);

Src/HALAL/Services/Diagnostics/DiagnosticSinks.cpp

@@ -229,12 +229,10 @@ class DiagnosticTransportOrder final : public Order {
 
 class OrderProtocolDiagnosticSink final : public DiagnosticSink {
 public:
-    explicit OrderProtocolDiagnosticSink(const char* ip = "192.168.0.9", uint16_t port = 31) {
-        ST_LIB::ProtectionADJv3Packet::tcp_client_init(ip, port);
-    }
+    explicit OrderProtocolDiagnosticSink(const char* ip = "192.168.0.9", uint16_t port = 31) {}
     bool publish(const DiagnosticRecord& record) override {
         auto package = ST_LIB::ProtectionADJv3Packet::make(
-            1234,
+            Order::last_order_ip,
             record.payload.protection.rule_kind,
             record.payload.protection.sample_encoding
         );

Src/ST-LIB_HIGH/Protections/ProtectionMessages.cpp

@@ -14,12 +14,14 @@ namespace ST_LIB {
 struct tcp_pcb* ProtectionADJv3Packet::tpcb = nullptr;
 bool ProtectionADJv3Packet::is_connected = false;
 
-ProtectionADJv3Packet::Package
-ProtectionADJv3Packet::make(uint16_t measurement_id, Protections::RuleKind prot, Protections::SampleEncoding valueSize) {
+ProtectionADJv3Packet::Package ProtectionADJv3Packet::make(
+    uint16_t measurement_id,
+    Protections::RuleKind prot,
+    Protections::SampleEncoding valueSize
+) {
     // Bit packing of protection into 3 most significant bits of id (Look adjv3 format)
     uint8_t numericValueSize;
-    switch (valueSize)
-    {
+    switch (valueSize) {
     case Protections::SampleEncoding::BOOL:
         numericValueSize = 1;
         break;
@@ -82,6 +84,7 @@ bool ProtectionADJv3Packet::tcp_client_init(const char* ip, uint16_t port) {
         tpcb = nullptr;
         return false;
     }
+    tcp_output(tpcb);
     return true;
 }
 bool ProtectionADJv3Packet::tcp_client_send(